firmware_tools/verification/mem_model/mem_model.v
2019-08-28 09:13:03 +01:00

231 lines
No EOL
5.6 KiB
Verilog

`timescale 1ps/1ps
module mem_model (
clk,
rst_n,
avs_address,
avs_write,
avs_writedata,
avs_read,
avs_readdata,
avm_rx_waitrequest,
avm_rx_burstcount,
avm_rx_address,
avm_rx_read,
avm_rx_readdata,
avm_rx_readdatavalid,
avm_tx_waitrequest,
avm_tx_burstcount,
avm_tx_address,
avm_tx_write,
avm_tx_writedata,
// SRAM style write port 0
wr_port_valid_0,
wr_port_data_0,
wr_port_addr_0,
// SRAM style write port 1
wr_port_valid_1,
wr_port_data_1,
wr_port_addr_1,
// SRAM style write port 2
wr_port_valid_2,
wr_port_data_2,
wr_port_addr_2,
// SRAM style write port 3
wr_port_valid_3,
wr_port_data_3,
wr_port_addr_3
);
input clk;
input rst_n;
input [31:0] avs_address;
input avs_write;
input [31:0] avs_writedata;
input avs_read;
output reg [31:0] avs_readdata;
output reg avm_rx_waitrequest;
input [11:0] avm_rx_burstcount;
input [31:0] avm_rx_address;
input avm_rx_read;
output reg [31:0] avm_rx_readdata;
output reg avm_rx_readdatavalid;
output reg avm_tx_waitrequest;
input [11:0] avm_tx_burstcount;
input [31:0] avm_tx_address;
input avm_tx_write;
input [31:0] avm_tx_writedata;
input wr_port_valid_0;
input [31:0] wr_port_data_0;
input [31:0] wr_port_addr_0;
input wr_port_valid_1;
input [31:0] wr_port_data_1;
input [31:0] wr_port_addr_1;
input wr_port_valid_2;
input [31:0] wr_port_data_2;
input [31:0] wr_port_addr_2;
input wr_port_valid_3;
input [31:0] wr_port_data_3;
input [31:0] wr_port_addr_3;
reg [31:0] rx_count;
reg [31:0] rd_addr;
reg [31:0] tx_count;
reg [31:0] wr_addr;
reg [31:0] readdata;
reg avm_rx_readdatavalid_int;
reg [31:0] avm_rx_readdata_int;
always @(posedge clk or negedge rst_n)
begin
if (rst_n == 1'b0)
begin
rx_count <= 32'h00000000;
rd_addr <= 32'h00000000;
tx_count <= 32'h00000000;
wr_addr <= 32'h00000000;
avm_tx_waitrequest <= 1'b0;
avm_rx_waitrequest <= 1'b0;
avm_rx_readdatavalid <= 1'b0;
avm_rx_readdatavalid_int <= 1'b0;
avs_readdata <= 32'h00000000;
end
else
begin
// Default some of the outputs
avs_readdata = 32'h00000000;
// Update the output valid signal wit that calculated last cycle
avm_rx_readdatavalid = avm_rx_readdatavalid_int;
// read data is valid (internally) whenever the RX counter is non-zero
avm_rx_readdatavalid_int = rx_count != 32'h00000000;
// Update RX bus output with value calculated from last cycle
avm_rx_readdata = avm_rx_readdata_int;
// Internal read data is updated from that fetched from model last cycle.
avm_rx_readdata_int = readdata;
// If a slave read, return memory contents
if (avs_read == 1'b1)
begin
$memread({avs_address[29:0], 2'b00}, avs_readdata);
end
@(negedge clk);
// If a slave write, update memory
if (avs_write == 1'b1)
begin
$memwrite({avs_address[29:0], 2'b00}, avs_writedata);
end
if (tx_count == 32'h00000000 && rx_count == 32'h00000000)
begin
avm_rx_waitrequest = 1'b0;
end
else
begin
avm_rx_waitrequest = 1'b1;
end
if (rx_count == 32'h00000000 || tx_count != 32'h00000000)
begin
avm_tx_waitrequest = 1'b0;
end
else
begin
avm_tx_waitrequest = 1'b1;
end
// If a new master read request comes in (and not active), latch the rx_count and address values
if (avm_rx_read == 1'b1 && avm_rx_waitrequest == 1'b0)
begin
// Load RX count with burst + 1 as we are going to decrement it immediately
rx_count = avm_rx_burstcount + 1;
rd_addr = avm_rx_address;
end
// If a new master write request comes in (and not active), latch the tx_count and address values
if (avm_tx_write == 1'b1 && avm_tx_waitrequest == 1'b0 && tx_count == 0)
begin
tx_count = avm_tx_burstcount;
wr_addr = avm_tx_address;
end
// If an active read transfer in progress, transfer data
if (rx_count != 32'h00000000)
begin
$memread(rd_addr, readdata);
// Decrement the word count
rx_count = rx_count - 32'h00000001;
// Increment the read address
rd_addr = rd_addr + 32'h00000004;
// Set the outputs with a valid word
//avm_rx_readdatavalid_int = 1'b1;
end
// If an active write transfer in progress, transfer data
if (avm_tx_write == 1'b1 && avm_tx_waitrequest == 1'b0 && tx_count != 32'h00000000)
begin
$memwrite(wr_addr, avm_tx_writedata);
// Decrement the word count
tx_count = tx_count - 32'h00000001;
// Increment the write address
wr_addr = wr_addr + 32'h00000004;
end
// If a write port access valid, write data
if (wr_port_valid_0 == 1'b1)
begin
$memwrite(wr_port_addr_0, wr_port_data_0);
end
if (wr_port_valid_1 == 1'b1)
begin
$memwrite(wr_port_addr_1, wr_port_data_1);
end
if (wr_port_valid_2 == 1'b1)
begin
$memwrite(wr_port_addr_2, wr_port_data_2);
end
if (wr_port_valid_3 == 1'b1)
begin
$memwrite(wr_port_addr_3, wr_port_data_3);
end
end
end
endmodule