Line 1341... |
Line 1341... |
if (we)
|
if (we)
|
ram[adr] <= d;
|
ram[adr] <= d;
|
q <= ram[adr];
|
q <= ram[adr];
|
end
|
end
|
endmodule
|
endmodule
|
module vl_ram_be ( d, adr, be, re, we, q, clk);
|
module vl_ram_be ( d, adr, be, we, q, clk);
|
parameter data_width = 32;
|
parameter data_width = 32;
|
parameter addr_width = 6;
|
parameter addr_width = 6;
|
parameter mem_size = 1<<addr_width;
|
parameter mem_size = 1<<addr_width;
|
input [(data_width-1):0] d;
|
input [(data_width-1):0] d;
|
input [(addr_width-1):0] adr;
|
input [(addr_width-1):0] adr;
|
input [(data_width/8)-1:0] be;
|
input [(data_width/8)-1:0] be;
|
input re;
|
|
input we;
|
input we;
|
output reg [(data_width-1):0] q;
|
output reg [(data_width-1):0] q;
|
input clk;
|
input clk;
|
`ifdef SYSTEMVERILOG
|
`ifdef SYSTEMVERILOG
|
logic [data_width/8-1:0][7:0] ram[0:mem_size-1];// # words = 1 << address width
|
logic [data_width/8-1:0][7:0] ram[0:mem_size-1];// # words = 1 << address width
|
Line 1378... |
Line 1377... |
if(be[3]) ram[adr][3] <= d[31:24];
|
if(be[3]) ram[adr][3] <= d[31:24];
|
if(be[2]) ram[adr][2] <= d[23:16];
|
if(be[2]) ram[adr][2] <= d[23:16];
|
if(be[1]) ram[adr][1] <= d[15:8];
|
if(be[1]) ram[adr][1] <= d[15:8];
|
if(be[0]) ram[adr][0] <= d[7:0];
|
if(be[0]) ram[adr][0] <= d[7:0];
|
end
|
end
|
if (re)
|
|
q <= ram[adr];
|
q <= ram[adr];
|
end
|
end
|
`else
|
`else
|
assign cke = {data_width/8{we}} & be;
|
assign cke = {data_width/8{we}} & be;
|
genvar i;
|
genvar i;
|
Line 1391... |
Line 1389... |
if (cke[i])
|
if (cke[i])
|
ram[adr][(i+1)*8-1:i*8] <= d[(i+1)*8-1:i*8];
|
ram[adr][(i+1)*8-1:i*8] <= d[(i+1)*8-1:i*8];
|
end
|
end
|
endgenerate
|
endgenerate
|
always @ (posedge clk)
|
always @ (posedge clk)
|
if (re)
|
|
q <= ram[adr];
|
q <= ram[adr];
|
`endif
|
`endif
|
// Function to access RAM (for use by Verilator).
|
// Function to access RAM (for use by Verilator).
|
function [31:0] get_mem;
|
function [31:0] get_mem;
|
// verilator public
|
// verilator public
|
Line 1504... |
Line 1501... |
q_b <= ram[adr_b];
|
q_b <= ram[adr_b];
|
if (we_b)
|
if (we_b)
|
ram[adr_b] <= d_b;
|
ram[adr_b] <= d_b;
|
end
|
end
|
endmodule
|
endmodule
|
module vl_dpram_be_2r2w ( d_a, q_a, adr_a, be_a, we_a, clk_a, d_b, q_b, adr_b, be_b, we_b, clk_b );
|
module vl_dpram_be_2r2w ( d_a, q_a, adr_a, be_a, re_a, we_a, clk_a, d_b, q_b, adr_b, re_b, we_b, clk_b );
|
parameter a_data_width = 32;
|
parameter a_data_width = 32;
|
parameter a_addr_width = 8;
|
parameter a_addr_width = 8;
|
parameter b_data_width = 64;
|
parameter b_data_width = 32;
|
parameter b_addr_width = 7;
|
localparam b_addr_width = a_data_width * a_addr_width / b_data_width;
|
//parameter mem_size = (a_addr_width>b_addr_width) ? (1<<a_addr_width) : (1<<b_addr_width);
|
parameter mem_size = (a_addr_width>b_addr_width) ? (1<<a_addr_width) : (1<<b_addr_width);
|
parameter mem_size = 1024;
|
|
input [(a_data_width-1):0] d_a;
|
input [(a_data_width-1):0] d_a;
|
input [(a_addr_width-1):0] adr_a;
|
input [(a_addr_width-1):0] adr_a;
|
input [(b_addr_width-1):0] adr_b;
|
input [(a_data_width/8-1):0] be_a;
|
input [(a_data_width/4-1):0] be_a;
|
input re_a;
|
input we_a;
|
input we_a;
|
output [(b_data_width-1):0] q_b;
|
|
input [(b_data_width-1):0] d_b;
|
|
output reg [(a_data_width-1):0] q_a;
|
output reg [(a_data_width-1):0] q_a;
|
input [(b_data_width/4-1):0] be_b;
|
input [(b_data_width-1):0] d_b;
|
input we_b;
|
input [(b_addr_width-1):0] adr_b;
|
|
input re_b,we_b;
|
|
output [(b_data_width-1):0] q_b;
|
input clk_a, clk_b;
|
input clk_a, clk_b;
|
reg [(b_data_width-1):0] q_b;
|
`ifdef SYSTEMVERILOG
|
|
// use a multi-dimensional packed array
|
|
//to model individual bytes within the word
|
generate
|
generate
|
if (a_data_width==32 & b_data_width==64) begin : inst32to64
|
if (a_data_width==32 & b_data_width==32) begin : dpram_3232
|
wire [63:0] tmp;
|
logic [3:0][7:0] ram [0:mem_size-1];
|
vl_dpram_2r2w
|
reg [a_addr_width-1:0] rd_adr_a;
|
# (.data_width(8), .addr_width(b_addr_width-3))
|
reg [b_addr_width-1:0] rd_adr_b;
|
ram0 (
|
always_ff@(posedge clk_a)
|
.d_a(d_a[7:0]),
|
begin
|
.q_a(tmp[7:0]),
|
if(we_a) begin
|
.adr_a(adr_a[a_addr_width-3-1:0]),
|
if(be_a[3]) ram[adr_a][3] <= d_a[31:24];
|
.we_a(we_a & be_a[0] & !adr_a[0]),
|
if(be_a[2]) ram[adr_a][2] <= d_a[23:16];
|
.clk_a(clk_a),
|
if(be_a[1]) ram[adr_a][1] <= d_a[15:8];
|
.d_b(d_b[7:0]),
|
if(be_a[0]) ram[adr_a][0] <= d_a[7:0];
|
.q_b(q_b[7:0]),
|
end
|
.adr_b(adr_b[b_addr_width-3-1:0]),
|
end
|
.we_b(we_b),
|
always@(posedge clk_a or posedge rst)
|
.clk_b(clk_b) );
|
if (rst)
|
vl_dpram_2r2w
|
rd_adr_a <= 0;
|
# (.data_width(8), .addr_width(b_addr_width-3))
|
else if (re_a)
|
ram1 (
|
rd_adr_a <= adr_a;
|
.d_a(d_a[7:0]),
|
assign q_a = ram[rd_adr_a];
|
.q_a(tmp[7:0]),
|
always_ff@(posedge clk_b)
|
.adr_a(adr_a[a_addr_width-3-1:0]),
|
if(we_b)
|
.we_a(we_a),
|
ram[adr_b] <= d_b;
|
.clk_a(clk_a),
|
always@(posedge clk_b or posedge rst)
|
.d_b(d_b[7:0]),
|
if (rst)
|
.q_b(q_b[7:0]),
|
rd_adr_b <= 0;
|
.adr_b(adr_b[b_addr_width-3-1:0]),
|
else if (re_b)
|
.we_b(we_b),
|
rd_adr_b <= adr_b;
|
.clk_b(clk_b) );
|
assign q_b = ram[rd_adr_b];
|
vl_dpram_2r2w
|
|
# (.data_width(8), .addr_width(b_addr_width-3))
|
|
ram2 (
|
|
.d_a(d_a[15:8]),
|
|
.q_a(tmp[7:0]),
|
|
.adr_a(adr_a[a_addr_width-3-1:0]),
|
|
.we_a(we_a),
|
|
.clk_a(clk_a),
|
|
.d_b(d_b[7:0]),
|
|
.q_b(q_b[7:0]),
|
|
.adr_b(adr_b[b_addr_width-3-1:0]),
|
|
.we_b(we_b),
|
|
.clk_b(clk_b) );
|
|
vl_dpram_2r2w
|
|
# (.data_width(8), .addr_width(b_addr_width-3))
|
|
ram3 (
|
|
.d_a(d_a[15:8]),
|
|
.q_a(tmp[7:0]),
|
|
.adr_a(adr_a[a_addr_width-3-1:0]),
|
|
.we_a(we_a),
|
|
.clk_a(clk_a),
|
|
.d_b(d_b[7:0]),
|
|
.q_b(q_b[7:0]),
|
|
.adr_b(adr_b[b_addr_width-3-1:0]),
|
|
.we_b(we_b),
|
|
.clk_b(clk_b) );
|
|
vl_dpram_2r2w
|
|
# (.data_width(8), .addr_width(b_addr_width-3))
|
|
ram4 (
|
|
.d_a(d_a[23:16]),
|
|
.q_a(tmp[7:0]),
|
|
.adr_a(adr_a[a_addr_width-3-1:0]),
|
|
.we_a(we_a),
|
|
.clk_a(clk_a),
|
|
.d_b(d_b[7:0]),
|
|
.q_b(q_b[7:0]),
|
|
.adr_b(adr_b[b_addr_width-3-1:0]),
|
|
.we_b(we_b),
|
|
.clk_b(clk_b) );
|
|
vl_dpram_2r2w
|
|
# (.data_width(8), .addr_width(b_addr_width-3))
|
|
ram5 (
|
|
.d_a(d_a[23:16]),
|
|
.q_a(tmp[7:0]),
|
|
.adr_a(adr_a[a_addr_width-3-1:0]),
|
|
.we_a(we_a),
|
|
.clk_a(clk_a),
|
|
.d_b(d_b[7:0]),
|
|
.q_b(q_b[7:0]),
|
|
.adr_b(adr_b[b_addr_width-3-1:0]),
|
|
.we_b(we_b),
|
|
.clk_b(clk_b) );
|
|
vl_dpram_2r2w
|
|
# (.data_width(8), .addr_width(b_addr_width-3))
|
|
ram6 (
|
|
.d_a(d_a[31:24]),
|
|
.q_a(tmp[7:0]),
|
|
.adr_a(adr_a[a_addr_width-3-1:0]),
|
|
.we_a(we_a),
|
|
.clk_a(clk_a),
|
|
.d_b(d_b[7:0]),
|
|
.q_b(q_b[7:0]),
|
|
.adr_b(adr_b[b_addr_width-3-1:0]),
|
|
.we_b(we_b),
|
|
.clk_b(clk_b) );
|
|
vl_dpram_2r2w
|
|
# (.data_width(8), .addr_width(b_addr_width-3))
|
|
ram7 (
|
|
.d_a(d_a[31:24]),
|
|
.q_a(tmp[7:0]),
|
|
.adr_a(adr_a[a_addr_width-3-1:0]),
|
|
.we_a(we_a),
|
|
.clk_a(clk_a),
|
|
.d_b(d_b[7:0]),
|
|
.q_b(q_b[7:0]),
|
|
.adr_b(adr_b[b_addr_width-3-1:0]),
|
|
.we_b(we_b),
|
|
.clk_b(clk_b) );
|
|
/*
|
|
reg [7:0] ram0 [mem_size/8-1:0];
|
|
wire [7:0] wea, web;
|
|
assign wea = we_a & be_a[0];
|
|
assign web = we_b & be_b[0];
|
|
always @ (posedge clk_a)
|
|
if (wea)
|
|
ram0[adr_a] <= d_a[7:0];
|
|
always @ (posedge clk_a)
|
|
q_a[7:0] <= ram0[adr_a];
|
|
always @ (posedge clk_a)
|
|
if (web)
|
|
ram0[adr_b] <= d_b[7:0];
|
|
always @ (posedge clk_b)
|
|
q_b[7:0] <= ram0[adr_b];
|
|
*/
|
|
end
|
end
|
endgenerate
|
endgenerate
|
/*
|
`else
|
generate for (i=0;i<addr_width/4;i=i+1) begin : be_rama
|
`endif
|
always @ (posedge clk_a)
|
|
if (we_a & be_a[i])
|
|
ram[adr_a][(i+1)*8-1:i*8] <= d_a[(i+1)*8-1:i*8];
|
|
end
|
|
endgenerate
|
|
always @ (posedge clk_a)
|
|
q_a <= ram[adr_a];
|
|
genvar i;
|
|
generate for (i=0;i<addr_width/4;i=i+1) begin : be_ramb
|
|
always @ (posedge clk_a)
|
|
if (we_b & be_b[i])
|
|
ram[adr_b][(i+1)*8-1:i*8] <= d_b[(i+1)*8-1:i*8];
|
|
end
|
|
endgenerate
|
|
always @ (posedge clk_b)
|
|
q_b <= ram[adr_b];
|
|
*/
|
|
/*
|
|
always @ (posedge clk_a)
|
|
begin
|
|
q_a <= ram[adr_a];
|
|
if (we_a)
|
|
ram[adr_a] <= d_a;
|
|
end
|
|
always @ (posedge clk_b)
|
|
begin
|
|
q_b <= ram[adr_b];
|
|
if (we_b)
|
|
ram[adr_b] <= d_b;
|
|
end
|
|
*/
|
|
endmodule
|
endmodule
|
// Content addresable memory, CAM
|
|
// FIFO
|
// FIFO
|
module vl_fifo_1r1w_fill_level_sync (
|
module vl_fifo_1r1w_fill_level_sync (
|
d, wr, fifo_full,
|
d, wr, fifo_full,
|
q, rd, fifo_empty,
|
q, rd, fifo_empty,
|
fill_level,
|
fill_level,
|
Line 2065... |
Line 1937... |
output [adr_width-1:0] adr_o;
|
output [adr_width-1:0] adr_o;
|
output ack_o;
|
output ack_o;
|
input clk, rst;
|
input clk, rst;
|
reg [adr_width-1:0] adr;
|
reg [adr_width-1:0] adr;
|
wire [max_burst_width-1:0] to_adr;
|
wire [max_burst_width-1:0] to_adr;
|
|
reg [max_burst_width-1:0] last_adr;
|
|
reg [1:0] last_cycle;
|
|
localparam idle = 2'b00;
|
|
localparam cyc = 2'b01;
|
|
localparam ws = 2'b10;
|
|
localparam eoc = 2'b11;
|
|
always @ (posedge clk or posedge rst)
|
|
if (rst)
|
|
last_adr <= {max_burst_width{1'b0}};
|
|
else
|
|
if (stb_i)
|
|
last_adr <=adr_o;
|
generate
|
generate
|
if (max_burst_width==0) begin : inst_0
|
if (max_burst_width==0) begin : inst_0
|
reg ack_o;
|
reg ack_o;
|
assign adr_o = adr_i;
|
assign adr_o = adr_i;
|
always @ (posedge clk or posedge rst)
|
always @ (posedge clk or posedge rst)
|
if (rst)
|
if (rst)
|
ack_o <= 1'b0;
|
ack_o <= 1'b0;
|
else
|
else
|
ack_o <= cyc_i & stb_i & !ack_o;
|
ack_o <= cyc_i & stb_i & !ack_o;
|
end else begin
|
end else begin
|
reg [1:0] last_cycle;
|
|
localparam idle = 2'b00;
|
|
localparam cyc = 2'b01;
|
|
localparam ws = 2'b10;
|
|
localparam eoc = 2'b11;
|
|
always @ (posedge clk or posedge rst)
|
always @ (posedge clk or posedge rst)
|
if (rst)
|
if (rst)
|
last_cycle <= idle;
|
last_cycle <= idle;
|
else
|
else
|
last_cycle <= (!cyc_i) ? idle :
|
last_cycle <= (!cyc_i) ? idle :
|
(cyc_i & ack_o & (cti_i==3'b000 | cti_i==3'b111)) ? eoc :
|
(cyc_i & ack_o & (cti_i==3'b000 | cti_i==3'b111)) ? eoc :
|
(cyc_i & !stb_i) ? ws :
|
(cyc_i & !stb_i) ? ws :
|
cyc;
|
cyc;
|
assign to_adr = (last_cycle==idle | last_cycle==eoc) ? adr_i[max_burst_width-1:0] : adr[max_burst_width-1:0];
|
assign to_adr = (last_cycle==idle | last_cycle==eoc) ? adr_i[max_burst_width-1:0] : adr[max_burst_width-1:0];
|
assign adr_o[max_burst_width-1:0] = (we_i) ? adr_i[max_burst_width-1:0] :
|
assign adr_o[max_burst_width-1:0] = (we_i) ? adr_i[max_burst_width-1:0] :
|
|
(!stb_i) ? last_adr :
|
(last_cycle==idle | last_cycle==eoc) ? adr_i[max_burst_width-1:0] :
|
(last_cycle==idle | last_cycle==eoc) ? adr_i[max_burst_width-1:0] :
|
adr[max_burst_width-1:0];
|
adr[max_burst_width-1:0];
|
assign ack_o = (last_cycle==cyc | last_cycle==ws) & stb_i;
|
assign ack_o = (last_cycle==cyc | last_cycle==ws) & stb_i;
|
end
|
end
|
endgenerate
|
endgenerate
|
Line 2128... |
Line 2008... |
if (max_burst_width==4) begin : inst_4
|
if (max_burst_width==4) begin : inst_4
|
always @ (posedge clk or posedge rst)
|
always @ (posedge clk or posedge rst)
|
if (rst)
|
if (rst)
|
adr <= 4'h0;
|
adr <= 4'h0;
|
else
|
else
|
if (cyc_i & stb_i)
|
if (stb_i) // | (!stb_i & last_cycle!=ws)) // for !stb_i restart with adr_i +1, only inc once
|
case (bte_i)
|
case (bte_i)
|
2'b01: adr[3:0] <= {to_adr[3:2],to_adr[1:0] + 2'd1};
|
2'b01: adr[3:0] <= {to_adr[3:2],to_adr[1:0] + 2'd1};
|
2'b10: adr[3:0] <= {to_adr[3],to_adr[2:0] + 3'd1};
|
2'b10: adr[3:0] <= {to_adr[3],to_adr[2:0] + 3'd1};
|
default: adr[3:0] <= to_adr + 4'd1;
|
default: adr[3:0] <= to_adr + 4'd1;
|
endcase
|
endcase
|
Line 2691... |
Line 2571... |
.memory_file(memory_file))
|
.memory_file(memory_file))
|
ram0(
|
ram0(
|
.d(wbs_dat_i),
|
.d(wbs_dat_i),
|
.adr(adr),
|
.adr(adr),
|
.be(wbs_sel_i),
|
.be(wbs_sel_i),
|
.re(wbs_stb_i),
|
|
.we(wbs_we_i & wbs_ack_o),
|
.we(wbs_we_i & wbs_ack_o),
|
.q(wbs_dat_o),
|
.q(wbs_dat_o),
|
.clk(wb_clk)
|
.clk(wb_clk)
|
);
|
);
|
vl_wb_adr_inc # ( .adr_width(aw), .max_burst_width(max_burst_width)) adr_inc0 (
|
vl_wb_adr_inc # ( .adr_width(aw), .max_burst_width(max_burst_width)) adr_inc0 (
|