231 lines
No EOL
5.6 KiB
Verilog
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 |