// ========== Copyright Header Begin ==========================================
// OpenSPARC T2 Processor File: axis_sram.v
// Copyright (C) 1995-2007 Sun Microsystems, Inc. All Rights Reserved
// 4150 Network Circle, Santa Clara, California 95054, U.S.A.
// * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; version 2 of the License.
// This program 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 General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
// For the avoidance of doubt, and except that if any non-GPL license
// choice is available it will apply instead, Sun elects to use only
// the General Public License version 2 (GPLv2) at this time for any
// software where a choice of GPL license versions is made
// available with the language indicating that GPLv2 or any later version
// may be used, or where a choice of which version of the GPL is applied is
// otherwise unspecified.
// Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
// CA 95054 USA or visit www.sun.com if you need additional information or
// ========== Copyright Header End ============================================
input [25:0] rd_adr1; // Bit 25 is address parity
wire [21:0] a_rd_adr0 = {rd_adr0[24:19],rd_adr0[15:0]};
wire [22:0] b_rd_adr0 = {rd_adr0[24:19],rd_adr0[16:0]};
wire [23:0] c_rd_adr0 = {rd_adr0[24:19],rd_adr0[17:0]};
wire [24:0] d_rd_adr0 = {rd_adr0[24:19],rd_adr0[18:0]};
wire [21:0] a_rd_adr1 = {rd_adr1[24:19],rd_adr1[15:0]};
wire [22:0] b_rd_adr1 = {rd_adr1[24:19],rd_adr1[16:0]};
wire [23:0] c_rd_adr1 = {rd_adr1[24:19],rd_adr1[17:0]};
wire [24:0] d_rd_adr1 = {rd_adr1[24:19],rd_adr1[18:0]};
wire [21:0] a_wr_adr0 = {wr_adr0[24:19],wr_adr0[15:0]};
wire [22:0] b_wr_adr0 = {wr_adr0[24:19],wr_adr0[16:0]};
wire [23:0] c_wr_adr0 = {wr_adr0[24:19],wr_adr0[17:0]};
wire [24:0] d_wr_adr0 = {wr_adr0[24:19],wr_adr0[18:0]};
wire [127:0] a_din_0 = din_0;
wire [ 16:0] a_ein_0 = {1'b1,din_0[143:128]};
reg /*sparse */ [127:0] DRAM [22'h3FFFFF:0];
assign dout0[127:0] = DRAM[(a_rd_adr0 & 22'h3FFFFF)];
assign dout1[127:0] = DRAM[(a_rd_adr1 & 22'h3FFFFF)];
reg /*sparse */ [127:0] DRAM [23'h7FFFFF:0];
assign dout0[127:0] = DRAM[(b_rd_adr0 & 23'h7FFFFF)];
assign dout1[127:0] = DRAM[(b_rd_adr1 & 23'h7FFFFF)];
reg /*sparse */ [127:0] DRAM [24'hFFFFFF:0];
assign dout0[127:0] = DRAM[(d_rd_adr0 & 24'hFFFFFF)];
assign dout1[127:0] = DRAM[(d_rd_adr1 & 24'hFFFFFF)];
reg /*sparse */ [127:0] DRAM [25'h1FFFFFF:0];
assign dout0[127:0] = DRAM[(d_rd_adr0 & 25'h1FFFFFF)];
assign dout1[127:0] = DRAM[(d_rd_adr1 & 25'h1FFFFFF)];
wire a0_we_0 = a_we_0 & ~c_wr_adr0[23];
wire a1_we_0 = a_we_0 & c_wr_adr0[23];
wire [127:0] a_din_0 = din_0[127:0];
always @(posedge clk) begin
`ifdef BLK_1GIG if (a_we_0) DRAM[(a_wr_adr0 & 22'h3FFFFF)] <= din_0; `endif
`ifdef BLK_2GIG if (a_we_0) DRAM[(b_wr_adr0 & 23'h7FFFFF)] <= din_0; `endif
`ifdef BLK_4GIG if (a0_we_0) DRAM [(c_wr_adr0 & 24'hFFFFFF)] <= din_0; `endif
`ifdef BLK_8GIG if (a_we_0) DRAM[(d_wr_adr0 & 25'h1FFFFFF)] <= din_0; `endif
if (we_0 & dram_dump) $display("WD=%h", din_0);
`else // !`ifdef PALLADIUM
dram_ecc_gen ecc_gen ( .data(dout1[127:0]), .ecc(ecc_out[15:0]) );
assign eout1[ 15:0] = a_eout1[16] ? a_eout1[15:0] : (ecc_out[15:0] ^ {16{rd_adr1[25]}});
assign dout0[127:0] = a_dout0;
assign dout1[127:0] = a_dout1;
axis_smem #(22, 128, 3, 0) DRAM
{128'bz, a_dout0, a_dout1 }, // Data Out
{a_din_0, 128'bz, 128'bz }, // Data In
{a_wr_adr0, a_rd_adr0, a_rd_adr1}, // Address
{a_we_0, 1'b0, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, 1'b1, 1'b1 }, // Chip Enable
{a_clk, 1'bz, 1'bz }, // Clocks : 1'bz means asynchronous
{128'bz, 128'bz, 128'bz } // Mask
axis_smem #(22, 17 , 2, 0) DRAM_ECC
{ 17'bz, a_eout1 }, // Data Out
{a_ein_0, 17'bz }, // Data In
{a_wr_adr0, a_rd_adr1}, // Address
{a_we_0, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, 1'b1 }, // Chip Enable
{a_clk, 1'bz }, // Clocks : 1'bz means asynchronous
axis_smem #(23, 128, 3, 0) DRAM
{128'bz, a_dout0, a_dout1 }, // Data Out
{a_din_0, 128'bz, 128'bz }, // Data In
{b_wr_adr0, b_rd_adr0, b_rd_adr1}, // Address
{a_we_0, 1'b0, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, 1'b1, 1'b1 }, // Chip Enable
{a_clk, 1'bz, 1'bz }, // Clocks : 1'bz means asynchronous
{128'bz, 128'bz, 128'bz } // Mask
axis_smem #(23, 17 , 2, 0) DRAM_ECC
{ 17'bz, a_eout1 }, // Data Out
{a_ein_0, 17'bz }, // Data In
{b_wr_adr0, b_rd_adr1}, // Address
{a_we_0, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, 1'b1 }, // Chip Enable
{a_clk, 1'bz }, // Clocks : 1'bz means asynchronous
wire [23:13] tag_addr_a = c_wr_adr0[23:13];
axis_smem #(24-13, 1, 1, 0, 1'b0) tag_a (
wire [23:13] tag_addr_b = c_wr_adr0[23:13];
axis_smem #(24-13, 1, 1, 0, 1'b0) tag_b (
wire [63:0] a_din0a=a_din_0[63:0];
wire [63:0] a_din0b=a_din_0[127:64];
assign a_dout0={a_dout0b,a_dout0a};
assign a_dout1={a_dout1b,a_dout1a};
initial $axis_initmem(0, DRAM);
initial $axis_initmem(0, DRAM1);
axis_smem #(24, 64, 3, 0, 1'b0, "D", "tag_a") DRAM
axis_smem #(24, 64, 3, 0) DRAM
{64'bz, a_dout0a, a_dout1a }, // Data Out
{a_din0a, 64'bz, 64'bz }, // Data In
{c_wr_adr0, c_rd_adr0, c_rd_adr1}, // Address
{a_we_0, 1'b0, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, 1'b1, 1'b1 }, // Chip Enable
{a_clk, 1'bz, 1'bz }, // Clocks : 1'bz means asynchronous
{64'bz, 64'bz, 64'bz } // Mask
axis_smem #(24, 64, 3, 0, 1'b0, "D", "tag_b") DRAM1
axis_smem #(24, 64, 3, 0) DRAM1
{64'bz, a_dout0b, a_dout1b }, // Data Out
{a_din0b, 64'bz, 64'bz }, // Data In
{c_wr_adr0, c_rd_adr0, c_rd_adr1}, // Address
{a_we_0, 1'b0, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, 1'b1, 1'b1 }, // Chip Enable
{a_clk, 1'bz, 1'bz }, // Clocks : 1'bz means asynchronous
{64'bz, 64'bz, 64'bz } // Mask
axis_smem #(24, 17 , 2, 0) DRAM_ECC
{ 17'bz, a_eout1 }, // Data Out
{a_ein_0, 17'bz }, // Data In
{c_wr_adr0, c_rd_adr1}, // Address
{a_we_0, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, 1'b1 }, // Chip Enable
{a_clk, 1'bz }, // Clocks : 1'bz means asynchronous
axis_smem #(25, 128, 3, 0) DRAM
{128'bz, a_dout0, a_dout1 }, // Data Out
{a_din_0, 128'bz, 128'bz }, // Data In
{d_wr_adr0, d_rd_adr0, d_rd_adr1}, // Address
{a_we_0, 1'b0, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, 1'b1, 1'b1 }, // Chip Enable
{a_clk, 1'bz, 1'bz }, // Clocks : 1'bz means asynchronous
{128'bz, 128'bz, 128'bz } // Mask
always @(posedge clk) begin
begin // axis tbcall_region
$display("WD=%h", din_0_r);
assign eout1[ 15:0] = (ecc_out[15:0] ^ {16{rd_adr1[25]}});
initial $display("WARNING: storage of ECC codes not supported in this dram model on non-axis platforms");
reg /*sparse */ [127:0] DRAM [22'h3FFFFF:0];
assign dout0[127:0] = DRAM[(a_rd_adr0 & 22'h3FFFFF)];
assign dout1[127:0] = DRAM[(a_rd_adr1 & 22'h3FFFFF)];
reg /*sparse */ [127:0] DRAM [23'h7FFFFF:0];
assign dout0[127:0] = DRAM[(b_rd_adr0 & 23'h7FFFFF)];
assign dout1[127:0] = DRAM[(b_rd_adr1 & 23'h7FFFFF)];
reg /*sparse */ [127:0] DRAM [24'hFFFFFF:0];
assign dout0[127:0] = DRAM[(d_rd_adr0 & 24'hFFFFFF)];
assign dout1[127:0] = DRAM[(d_rd_adr1 & 24'hFFFFFF)];
reg /*sparse */ [127:0] DRAM [25'h1FFFFFF:0];
assign dout0[127:0] = DRAM[(d_rd_adr0 & 25'h1FFFFFF)];
assign dout1[127:0] = DRAM[(d_rd_adr1 & 25'h1FFFFFF)];
`ifdef BLK_1GIG for (j=22'h3F0000 ; j<=22'h3FFFFF ; j=j+1) DRAM [j] = 128'h0; `endif
`ifdef BLK_2GIG for (j=23'h7E0000 ; j<=23'h7FFFFF ; j=j+1) DRAM [j] = 128'h0; `endif
`ifdef BLK_4GIG for (j=23'h7C0000 ; j<=24'h7FFFFF ; j=j+1) DRAM [j] = 128'h0; `endif
`ifdef BLK_4GIG for (j=20'h00000 ; j<=24'hFFFFF ; j=j+1) DRAM [j] = 128'h0; `endif
`ifdef BLK_8GIG for (j=25'h1F80000; j<=25'h1FFFFFF; j=j+1) DRAM [j] = 128'h0; `endif
wire a0_we_0 = a_we_0 & ~c_wr_adr0[23];
wire a1_we_0 = a_we_0 & c_wr_adr0[23];
always @(posedge clk) begin
`ifdef BLK_1GIG if (a_we_0) DRAM[(a_wr_adr0 & 22'h3FFFFF)] <= din_0; `endif
`ifdef BLK_2GIG if (a_we_0) DRAM[(b_wr_adr0 & 23'h7FFFFF)] <= din_0; `endif
`ifdef BLK_4GIG if (a0_we_0) DRAM [(c_wr_adr0 & 24'hFFFFFF)] <= din_0; `endif
`ifdef BLK_8GIG if (a_we_0) DRAM[(d_wr_adr0 & 25'h1FFFFFF)] <= din_0; `endif
if (we_0 & dram_dump) $display("WD=%h", din_0);
`endif // !`ifdef PALLADIUM
wire [15:0] a_adr0 = adr0[15:0];
wire [15:0] a_adr1 = adr1[15:0];
wire [15:0] a_adr2 = adr2[15:0];
wire [15:0] a_adr3 = adr3[15:0];
wire [15:0] a_adr4 = adr4[15:0];
wire [16:0] b_adr0 = adr0[16:0];
wire [16:0] b_adr1 = adr1[16:0];
wire [16:0] b_adr2 = adr2[16:0];
wire [16:0] b_adr3 = adr3[16:0];
wire [16:0] b_adr4 = adr4[16:0];
wire [17:0] c_adr0 = adr0[17:0];
wire [17:0] c_adr1 = adr1[17:0];
wire [17:0] c_adr2 = adr2[17:0];
wire [17:0] c_adr3 = adr3[17:0];
wire [17:0] c_adr4 = adr4[17:0];
wire [18:0] d_adr0 = adr0[18:0];
wire [18:0] d_adr1 = adr1[18:0];
wire [18:0] d_adr2 = adr2[18:0];
wire [18:0] d_adr3 = adr3[18:0];
wire [18:0] d_adr4 = adr4[18:0];
reg /*sparse */ [31:0] DRAM_DIR [16'hFFFF:0];
assign data0[31:0] = DRAM_DIR[a_adr0];
assign data1[31:0] = DRAM_DIR[a_adr1];
assign data2[31:0] = DRAM_DIR[a_adr2];
assign data3[31:0] = DRAM_DIR[a_adr3];
assign data4[31:0] = DRAM_DIR[a_adr4];
reg [31:0] DRAM_DIR [17'h1FFFF:0];
assign data0[31:0] = DRAM_DIR[b_adr0];
assign data1[31:0] = DRAM_DIR[b_adr1];
assign data2[31:0] = DRAM_DIR[b_adr2];
assign data3[31:0] = DRAM_DIR[b_adr3];
assign data4[31:0] = DRAM_DIR[b_adr4];
reg [31:0] DRAM_DIR [18'h3FFFF:0];
assign data0[31:0] = DRAM_DIR[c_adr0];
assign data1[31:0] = DRAM_DIR[c_adr1];
assign data2[31:0] = DRAM_DIR[c_adr2];
assign data3[31:0] = DRAM_DIR[c_adr3];
assign data4[31:0] = DRAM_DIR[c_adr4];
reg [31:0] DRAM_DIR [19'h7FFFF:0];
assign data0[31:0] = DRAM_DIR[d_adr0];
assign data1[31:0] = DRAM_DIR[d_adr1];
assign data2[31:0] = DRAM_DIR[d_adr2];
assign data3[31:0] = DRAM_DIR[d_adr3];
assign data4[31:0] = DRAM_DIR[d_adr4];
`else // !`ifdef PALLADIUM
assign data0[31:0] = a_data0;
assign data1[31:0] = a_data1;
assign data2[31:0] = a_data2;
assign data3[31:0] = a_data3;
assign data4[31:0] = a_data4;
axis_smem #(16, 32, 5, 0) DRAM_DIR
{a_data0, a_data1, a_data2, a_data3, a_data4}, // Data Out
{32'bz , 32'bz, 32'bz, 32'bz, 32'bz}, // Data In
{a_adr0 , a_adr1, a_adr2, a_adr3, a_adr4 }, // Address
{1'b0 , 1'b0 , 1'b0, 1'b0, 1'b0 }, // Write Enable : 1'b0 means always read
{1'b1 , 1'b1 , 1'b1, 1'b1, 1'b1 }, // Chip Enable
{1'bz , 1'bz , 1'bz, 1'bz, 1'bz }, // Clocks : 1'bz means asynchronous
{32'bz , 32'bz , 32'bz, 32'bz, 32'bz } // Mask
axis_smem #(17, 32, 5, 0) DRAM_DIR
{a_data0, a_data1, a_data2, a_data3, a_data4}, // Data Out
{32'bz , 32'bz, 32'bz, 32'bz, 32'bz}, // Data In
{b_adr0 , b_adr1, b_adr2, b_adr3, b_adr4 }, // Address
{1'b0 , 1'b0 , 1'b0, 1'b0, 1'b0 }, // Write Enable : 1'b0 means always read
{1'b1 , 1'b1 , 1'b1, 1'b1, 1'b1 }, // Chip Enable
{1'bz , 1'bz , 1'bz, 1'bz, 1'bz }, // Clocks : 1'bz means asynchronous
{32'bz , 32'bz , 32'bz, 32'bz, 32'bz } // Mask
axis_smem #(18, 32, 5, 0) DRAM_DIR
{a_data0, a_data1, a_data2, a_data3, a_data4}, // Data Out
{32'bz , 32'bz, 32'bz, 32'bz, 32'bz}, // Data In
{c_adr0 , c_adr1, c_adr2, c_adr3, c_adr4 }, // Address
{1'b0 , 1'b0 , 1'b0, 1'b0, 1'b0 }, // Write Enable : 1'b0 means always read
{1'b1 , 1'b1 , 1'b1, 1'b1, 1'b1 }, // Chip Enable
{1'bz , 1'bz , 1'bz, 1'bz, 1'bz }, // Clocks : 1'bz means asynchronous
{32'bz , 32'bz , 32'bz, 32'bz, 32'bz } // Mask
axis_smem #(19, 32, 5, 0) DRAM_DIR
{a_data0, a_data1, a_data2, a_data3, a_data4}, // Data Out
{32'bz , 32'bz, 32'bz, 32'bz, 32'bz}, // Data In
{d_adr0 , d_adr1, d_adr2, d_adr3, d_adr4 }, // Address
{1'b0 , 1'b0 , 1'b0, 1'b0, 1'b0 }, // Write Enable : 1'b0 means always read
{1'b1 , 1'b1 , 1'b1, 1'b1, 1'b1 }, // Chip Enable
{1'bz , 1'bz , 1'bz, 1'bz, 1'bz }, // Clocks : 1'bz means asynchronous
{32'bz , 32'bz , 32'bz, 32'bz, 32'bz } // Mask
reg /*sparse */ [31:0] DRAM_DIR [16'hFFFF:0];
assign data0[31:0] = DRAM_DIR[a_adr0];
assign data1[31:0] = DRAM_DIR[a_adr1];
assign data2[31:0] = DRAM_DIR[a_adr2];
assign data3[31:0] = DRAM_DIR[a_adr3];
assign data4[31:0] = DRAM_DIR[a_adr4];
reg [31:0] DRAM_DIR [17'h1FFFF:0];
assign data0[31:0] = DRAM_DIR[b_adr0];
assign data1[31:0] = DRAM_DIR[b_adr1];
assign data2[31:0] = DRAM_DIR[b_adr2];
assign data3[31:0] = DRAM_DIR[b_adr3];
assign data4[31:0] = DRAM_DIR[b_adr4];
reg [31:0] DRAM_DIR [18'h3FFFF:0];
assign data0[31:0] = DRAM_DIR[c_adr0];
assign data1[31:0] = DRAM_DIR[c_adr1];
assign data2[31:0] = DRAM_DIR[c_adr2];
assign data3[31:0] = DRAM_DIR[c_adr3];
assign data4[31:0] = DRAM_DIR[c_adr4];
reg [31:0] DRAM_DIR [19'h7FFFF:0];
assign data0[31:0] = DRAM_DIR[d_adr0];
assign data1[31:0] = DRAM_DIR[d_adr1];
assign data2[31:0] = DRAM_DIR[d_adr2];
assign data3[31:0] = DRAM_DIR[d_adr3];
assign data4[31:0] = DRAM_DIR[d_adr4];
for(j=0 ; j<=65535; j=j+1) begin
DRAM_DIR [j] = 32'hDEADBEEF;
`endif // !`ifdef PALLADIUM
module l2data_axis (data_out, rclk, adr, data_in, we, wm);
wire [127:0] a_data_in = {data_in[155:124],data_in[116:85],data_in[77:46],data_in[38:7]};
wire [127:0] a_wm = {wm[155:124],wm[116:85],wm[77:46],wm[38:7]};
axis_smem #(10, 128, 2, 0) L2
{128'bz, c_data_out }, // Data Out
{a_data_in, 128'bz }, // Data In
{a_adr, a_adr }, // Address
{a_we, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, 1'b1 }, // Chip Enable
{a_rclk, 1'bz }, // Clocks : 1'bz means asynchronous
assign b_data_out = c_data_out;
/*****************************
always @(posedge a_rclk) begin
begin // axis tbcall_region
$display("L2 ADR=%h WM=%h WD=%h", a_adr_r, a_wm_r, din_0_r);
*****************************/
initial ERR_BIT = 256'h1;
assign b_data_out[127:0] = L2[adr];
wire [128:0] l2_in = (~a_wm[127:0] & b_data_out) | (a_wm[127:0] & a_data_in);
always @(posedge rclk) begin
if (we) L2[adr] <= l2_in;
ERR_BIT <= {ERR_BIT[254:0], ERR_BIT[255]};
zzecc_sctag_pgen_32b ecc3 ( .dout(a_data_out[155:124]), .parity(a_data_out[123:117]), .din(b_data_out[127:96]) );
zzecc_sctag_pgen_32b ecc2 ( .dout(a_data_out[116: 85]), .parity(a_data_out[ 84: 78]), .din(b_data_out[ 95:64]) );
zzecc_sctag_pgen_32b ecc1 ( .dout(a_data_out[ 77: 46]), .parity(a_data_out[ 45: 39]), .din(b_data_out[ 63:32]) );
zzecc_sctag_pgen_32b ecc0 ( .dout(a_data_out[ 38: 7]), .parity(a_data_out[ 6: 0]), .din(b_data_out[ 31: 0]) );
assign data_out[155:0] = a_data_out[155:0]; // ^ ERR_BIT[155:0];
module zzecc_sctag_pgen_32b ( dout, parity, din);
//Output: 32bit dout and 7bit parity bit
module l2tag_axis (rclk, adr, we, tag_in, tag_out);
wire [ 27:0] a_tag_in = tag_in;
assign tag_out[27:0] = a_tag_out;
axis_smem #(10, 28, 2, 0) L2_TAG
{ 28'bz, a_tag_out }, // Data Out
{a_tag_in, 28'bz }, // Data In
{a_adr, a_adr }, // Address
{1'b1, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, 1'b1 }, // Chip Enable
{a_rclk, 1'bz }, // Clocks : 1'bz means asynchronous
reg [ 27:0] L2_TAG [1023:0];
assign tag_out[ 27:0] = L2_TAG[adr];
wire [ 27:0] l2_in = (~we[ 27:0] & tag_out) | (we[ 27:0] & tag_in);
always @(posedge rclk) begin
module ic_data ( nclk, adr, we, din, dout );
wire [543:0] a_din = din;
assign dout[543:0] = a_dout;
axis_smem #(8, 544, 2, 0) IC
{544'bz, a_dout }, // Data Out
{a_din, 544'bz }, // Data In
{a_adr, a_adr }, // Address
{1'b1, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, 1'b1 }, // Chip Enable
{a_nclk, 1'bz }, // Clocks : 1'bz means asynchronous
assign dout[543:0] = IC[adr];
wire [543:0] ic_in = (~we[543:0] & dout) | (we[543:0] & din);
always @(posedge nclk) begin // Clock was inverted
module dc_data (nclk, adr, we, wm, din, dout );
wire [143:0] a_din = din;
assign dout[143:0] = a_dout;
axis_smem #(7, 144, 2, 0) DC
{144'bz, a_dout }, // Data Out
{a_din, 144'bz }, // Data In
{a_adr, a_adr }, // Address
{a_we, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, 1'b1 }, // Chip Enable
{a_nclk, 1'bz }, // Clocks : 1'bz means asynchronous
assign dout[143:0] = DC[adr];
wire [143:0] dc_in = (~wm[143:0] & dout) | (wm[143:0] & din);
always @(posedge nclk) begin // Clock was inverted
if (we) DC[adr] <= dc_in;
//if (we) $display(" DC write ADR=%h, DATA=%h", adr, dc_in);
module l1_tag (nclk, adr, we, wm, din, dout );
wire [6:0] snoop_adr = (test_cmp.cmp_sat.SNOOP_CNT == 4) ? {test_cmp.cmp_sat.dram_adr_inclusive[11:6], 1'b0} :
(test_cmp.cmp_sat.SNOOP_CNT == 5) ? {test_cmp.cmp_sat.dram_adr_inclusive[11:6], 1'b1} :
{test_cmp.cmp_sat.dram_adr_inclusive[10:6], test_cmp.cmp_sat.SNOOP_CNT[1:0]};
wire [131:0] a_din = din;
assign dout[131:0] = a_dout;
axis_smem #(7, 132, 3, 0) TG
{132'bz, a_dout, b_dout }, // Data Out
{a_din, 132'bz, 132'bz }, // Data In
{a_adr, a_adr, snoop_adr }, // Address
{a_we, 1'b0, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, 1'b1, 1'b1 }, // Chip Enable
{a_nclk, 1'bz, 1'bz }, // Clocks : 1'bz means asynchronous
{a_wm, 132'bz, 132'bz } // Mask
wire [131:0] snoop_out = b_dout;
assign dout[131:0] = TG[adr];
wire [131:0] tg_in = (~wm[131:0] & dout) | (wm[131:0] & din);
always @(posedge nclk) begin // Clock was inverted
if (we) TG[adr] <= tg_in;
wire [131:0] snoop_out = TG[snoop_adr];
assign snoop_err_dc[0] = (test_cmp.cmp_sat.dram_adr_inclusive != 0) &
(test_cmp.cmp_sat.dram_adr_inclusive[36:11] == snoop_out[ 25: 0]);
assign snoop_err_dc[1] = (test_cmp.cmp_sat.dram_adr_inclusive != 0) &
(test_cmp.cmp_sat.dram_adr_inclusive[36:11] == snoop_out[ 58:33]);
assign snoop_err_dc[2] = (test_cmp.cmp_sat.dram_adr_inclusive != 0) &
(test_cmp.cmp_sat.dram_adr_inclusive[36:11] == snoop_out[ 91:66]);
assign snoop_err_dc[3] = (test_cmp.cmp_sat.dram_adr_inclusive != 0) &
(test_cmp.cmp_sat.dram_adr_inclusive[36:11] == snoop_out[124:99]);
assign snoop_err_ic[0] = (test_cmp.cmp_sat.dram_adr_inclusive != 0) &
(test_cmp.cmp_sat.dram_adr_inclusive[36:12] == snoop_out[ 24: 0]);
assign snoop_err_ic[1] = (test_cmp.cmp_sat.dram_adr_inclusive != 0) &
(test_cmp.cmp_sat.dram_adr_inclusive[36:12] == snoop_out[ 57:33]);
assign snoop_err_ic[2] = (test_cmp.cmp_sat.dram_adr_inclusive != 0) &
(test_cmp.cmp_sat.dram_adr_inclusive[36:12] == snoop_out[ 90:66]);
assign snoop_err_ic[3] = (test_cmp.cmp_sat.dram_adr_inclusive != 0) &
(test_cmp.cmp_sat.dram_adr_inclusive[36:12] == snoop_out[123:99]);
module rf32x108 ( rclk, radr, wadr, ren, we, wm, din, dout );
wire [ 4:0] a_radr = radr;
wire [ 4:0] a_wadr = wadr;
wire [107:0] a_din = din;
assign dout[107:0] = a_dout;
axis_smem #(5, 108, 2, 0) REGF32X108
{108'bz, a_dout }, // Data Out
{a_din, 108'bz }, // Data In
{a_wadr, a_radr }, // Address
{a_we, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, a_ren }, // Chip Enable
{a_rclk, 1'bz }, // Clocks : 1'bz means asynchronous
reg [107:0] REGF32X108 [31:0];
for(j=0 ; j<=31; j=j+1) begin
assign dout[107:0] = ren ? REGF32X108[radr] : LAST;
wire [107:0] rf_in = (~wm[107:0] & REGF32X108[wadr]) | (wm[107:0] & din);
always @(posedge rclk) begin
if (we) REGF32X108[wadr] <= rf_in;
module rf128x78 ( rclk, radr, wadr, ren, we, wm, din, dout );
wire [ 6:0] a_radr = radr;
wire [ 6:0] a_wadr = wadr;
wire [ 77:0] a_din = din;
assign dout[ 77:0] = a_dout;
axis_smem #(7, 78, 2, 0) REGF128X78
{ 78'bz, a_dout }, // Data Out
{a_din, 78'bz }, // Data In
{a_wadr, a_radr }, // Address
{a_we, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, a_ren }, // Chip Enable
{a_rclk, 1'bz }, // Clocks : 1'bz means asynchronous
reg [ 77:0] REGF128X78 [127:0];
for(j=0 ; j<=127; j=j+1) begin
assign dout[ 77:0] = ren ? REGF128X78[radr] : LAST;
wire [ 77:0] rf_in = (~wm[ 77:0] & REGF128X78[wadr]) | (wm[ 77:0] & din);
always @(posedge rclk) begin
if (we) REGF128X78[wadr] <= rf_in;
module rf16x128 ( rclk, radr, wadr, ren, we, wm, din, dout );
wire [ 3:0] a_radr = radr;
wire [ 3:0] a_wadr = wadr;
wire [127:0] a_din = din;
always @(posedge rclk) begin
LAST <= a_ren ? a_dout : LAST;
assign dout[127:0] = LAST;
assign dout[127:0] = a_dout;
axis_smem #(4,128, 2, 0) REGF32X80
{128'bz, a_dout }, // Data Out
{a_din, 128'bz }, // Data In
{a_wadr, a_radr }, // Address
{a_we, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, a_ren }, // Chip Enable
{a_rclk, 1'bz }, // Clocks : 1'bz means asynchronous
reg [127:0] REGF16X128 [15:0];
for(j=0 ; j<=15; j=j+1) begin
//assign dout[127:0] = LAST;
assign dout[127:0] = REGF16X128[radr];
wire [127:0] rf_in = (~wm[127:0] & REGF16X128[wadr]) | (wm[127:0] & din);
always @(posedge rclk) begin
if (we) REGF16X128[wadr] <= rf_in;
//LAST <= ren ? REGF16X128[radr] : LAST;
module rf32x80 ( rclk, radr, wadr, ren, we, wm, din, dout );
wire [ 4:0] a_radr = radr;
wire [ 4:0] a_wadr = wadr;
wire [ 79:0] a_din = din;
always @(posedge rclk) begin
LAST <= a_ren ? a_dout : LAST;
assign dout[ 79:0] = LAST;
axis_smem #(5, 80, 2, 0) REGF32X80
{ 80'bz, a_dout }, // Data Out
{a_din, 80'bz }, // Data In
{a_wadr, a_radr }, // Address
{a_we, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, a_ren }, // Chip Enable
{a_rclk, 1'bz }, // Clocks : 1'bz means asynchronous
reg [ 79:0] REGF32X80 [31:0];
for(j=0 ; j<=31; j=j+1) begin
assign dout[ 79:0] = LAST;
wire [ 79:0] rf_in = (~wm[ 79:0] & REGF32X80[wadr]) | (wm[ 79:0] & din);
always @(posedge rclk) begin
if (we) REGF32X80[wadr] <= rf_in;
LAST <= ren ? REGF32X80[radr] : LAST;
module rf32x152 ( rclk, radr, wadr, ren, we, wm, din, dout );
wire [ 4:0] a_radr = radr;
wire [ 4:0] a_wadr = wadr;
wire [151:0] a_din = din;
always @(posedge rclk) begin
LAST <= a_ren ? a_dout : LAST;
assign dout[151:0] = LAST;
axis_smem #(5, 152, 2, 0) REGF32X152
{152'bz, a_dout }, // Data Out
{a_din, 152'bz }, // Data In
{a_wadr, a_radr }, // Address
{a_we, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, a_ren }, // Chip Enable
{a_rclk, 1'bz }, // Clocks : 1'bz means asynchronous
reg [151:0] REGF32X152 [31:0];
for(j=0 ; j<=31; j=j+1) begin
assign dout[151:0] = LAST;
wire [151:0] rf_in = (~wm[151:0] & REGF32X152[wadr]) | (wm[151:0] & din);
always @(posedge rclk) begin
if (we) REGF32X152[wadr] <= rf_in;
LAST <= ren ? REGF32X152[radr] : LAST;
module rf16x160 ( rdclk, wrclk, radr, wadr, ren, we, wm, din, dout );
wire [ 3:0] a_radr = radr;
wire [ 3:0] a_wadr = wadr;
wire [159:0] a_din = din;
assign dout[159:0] = a_dout;
axis_smem #(4, 160, 2, 0) REGF16X160
{160'bz, a_dout }, // Data Out
{a_din, 160'bz }, // Data In
{a_wadr, a_radr }, // Address
{a_we, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, a_ren }, // Chip Enable
{a_wrclk, 1'bz }, // Clocks : 1'bz means asynchronous
reg [159:0] REGF16X160 [15:0];
for(j=0 ; j<=15; j=j+1) begin
assign dout[159:0] = ren ? REGF16X160[radr] : LAST;
wire [159:0] rf_in = (~wm[159:0] & REGF16X160[wadr]) | (wm[159:0] & din);
always @(posedge wrclk) begin
if (we) REGF16X160[wadr] <= rf_in;
always @(posedge rdclk) begin
module rf16x65 ( rdclk, wrclk, radr, wadr, ren, we, wm, din, dout );
wire [ 3:0] a_radr = radr;
wire [ 3:0] a_wadr = wadr;
wire [ 64:0] a_din = din;
//assign dout[ 64:0] = a_dout;
assign dout[ 64:0] = ren ? a_dout : 65'h1FFFFFFFFFFFFFFFF;
axis_smem #(4, 65, 2, 0) REGF16X65
{ 65'bz, a_dout }, // Data Out
{a_din, 65'bz }, // Data In
{a_wadr, a_radr }, // Address
{a_we, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, a_ren }, // Chip Enable
{a_wrclk, 1'bz }, // Clocks : 1'bz means asynchronous
reg [ 64:0] REGF16X65 [15:0];
for(j=0 ; j<=15; j=j+1) begin
assign dout[ 64:0] = ren ? REGF16X65 [radr] : LAST;
wire [ 64:0] rf_in = (~wm[ 64:0] & REGF16X65 [wadr]) | (wm[ 64:0] & din);
always @(posedge wrclk) begin
if (we) REGF16X65 [wadr] <= rf_in;
always @(posedge rdclk) begin
LAST <= 65'h1FFFFFFFFFFFFFFFF;
wire [19:0] a_adr0 = adr0;
wire [19:0] a_adr1 = adr1;
assign data0[208:0] = a_data0;
assign data1[208:0] = a_data1;
axis_smem #(20, 209, 2, 0) DBUFF
{a_data0, a_data1}, // Data Out
{209'bz, 209'bz }, // Data In
{a_adr0, a_adr1 }, // Address
{1'b0, 1'b0 }, // Write Enable : 1'b0 means always read
{1'b1, 1'b1 }, // Chip Enable
{1'bz, 1'bz }, // Clocks : 1'bz means asynchronous
{209'bz, 209'bz } // Mask
reg /*sparse */ [208:0] DBUFF [20'hFFFFF:0];
for(j=0 ; j<=1048575; j=j+1) begin
assign data0[208:0] = DBUFF[adr0];
assign data1[208:0] = DBUFF[adr1];
module rf2x32 ( rclk, radr, wadr, ren, we, wm, din, dout );
reg [ 31:0] REGF2X32 [ 1:0];
for(j=0 ; j<=1 ; j=j+1) begin
assign dout[ 31:0] = LAST;
wire [ 31:0] rf_in = (~wm[ 31:0] & REGF2X32[wadr]) | (wm[ 31:0] & din);
always @(posedge rclk) begin
if (we) REGF2X32[wadr] <= rf_in;
LAST <= ren ? REGF2X32[radr] : LAST;
wire [2:0] a_radr = {2'b0, radr}; // AXIS memory must have more than 4 entries
wire [2:0] a_wadr = {2'b0, wadr};
wire [ 31:0] a_din = din;
always @(posedge rclk) begin
LAST <= a_ren ? a_dout : LAST;
assign dout[ 31:0] = LAST;
axis_smem #(3, 32, 2, 0) REGF2X32
{ 32'bz, a_dout }, // Data Out
{a_din, 32'bz }, // Data In
{a_wadr, a_radr }, // Address
{a_we, 1'b0 }, // Write Enable : Active High , 1'b0 means always read
{1'b1, a_ren }, // Chip Enable
{a_rclk, 1'bz }, // Clocks : 1'bz means asynchronous
reg [ 31:0] REGF2X32 [ 1:0];
for(j=0 ; j<=1 ; j=j+1) begin
assign dout[ 31:0] = LAST;
wire [ 31:0] rf_in = (~wm[ 31:0] & REGF2X32[wadr]) | (wm[ 31:0] & din);
always @(posedge rclk) begin
if (we) REGF2X32[wadr] <= rf_in;
LAST <= ren ? REGF2X32[radr] : LAST;
`endif // !`ifdef PALLADIUM