// ========== Copyright Header Begin ==========================================
// OpenSPARC T2 Processor File: gkt_ipd_dp.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 ============================================
wire ncu_spc_l2_idx_hash_en_buf;
wire slow_cmp_sync_en_ff;
wire [39:0] mmu_l15_addr1;
wire [25:0] lsu_l15_cpkt1;
wire [25:0] spu_l15_cpkt1;
wire [39:0] spu_l15_addr1;
wire [25:0] mmu_l15_cpkt1;
wire [25:0] ifu_l15_cpkt1;
wire i_cpx_data1lo_reg_scanin;
wire i_cpx_data1lo_reg_scanout;
wire [145:0] l15_spc_data;
wire i_cpx_data1hi_reg_scanin;
wire i_cpx_data1hi_reg_scanout;
wire i_cpx_cpkt_reg_scanin;
wire i_cpx_cpkt_reg_scanout;
wire i_req_li_reg_scanin;
wire i_req_li_reg_scanout;
wire i_ifu_addr_v1_muxreg_scanin;
wire i_ifu_addr_v1_muxreg_scanout;
wire i_ifu_addr_v0_muxreg_scanin;
wire i_ifu_addr_v0_muxreg_scanout;
wire i_mmu_addr_v1_muxreg_scanin;
wire i_mmu_addr_v1_muxreg_scanout;
wire i_mmu_addr_v0_muxreg_scanin;
wire i_mmu_addr_v0_muxreg_scanout;
wire i_lsu_addr_v1_muxreg_scanin;
wire i_lsu_addr_v1_muxreg_scanout;
wire i_lsu_addr_v0_muxreg_scanin;
wire i_lsu_addr_v0_muxreg_scanout;
wire i_lsu_data_v1_muxreg_scanin;
wire i_lsu_data_v1_muxreg_scanout;
wire i_lsu_data_v0_muxreg_scanin;
wire i_lsu_data_v0_muxreg_scanout;
wire i_spu_addr_v1_muxreg_scanin;
wire i_spu_addr_v1_muxreg_scanout;
wire i_spu_addr_v0_muxreg_scanin;
wire i_spu_addr_v0_muxreg_scanout;
wire i_spu_data_v1_muxreg_scanin;
wire i_spu_data_v1_muxreg_scanout;
wire i_spu_data_v0_muxreg_scanin;
wire i_spu_data_v0_muxreg_scanout;
wire i_ifu_addr_drop_reg_scanin;
wire i_ifu_addr_drop_reg_scanout;
wire [25:0] drop_ifu_cpkt;
wire [39:0] drop_ifu_addr;
wire i_mmu_addr_drop_reg_scanin;
wire i_mmu_addr_drop_reg_scanout;
wire [25:0] drop_mmu_cpkt;
wire [39:0] drop_mmu_addr;
wire i_lsu_addr_drop_reg_scanin;
wire i_lsu_addr_drop_reg_scanout;
wire [25:0] drop_lsu_cpkt;
wire [39:0] drop_lsu_addr;
wire i_spu_addr_drop_reg_scanin;
wire i_spu_addr_drop_reg_scanout;
wire [25:0] drop_spu_cpkt;
wire [39:0] drop_spu_addr;
wire i_lsu_data_drop_reg_scanin;
wire i_lsu_data_drop_reg_scanout;
wire [63:0] drop_lsu_data;
wire i_spu_data_drop_reg_scanin;
wire i_spu_data_drop_reg_scanout;
wire [63:0] drop_spu_data;
wire [39:0] ipd_addr_l1_prebuf;
wire i_hash_en_ff2_scanin;
wire i_hash_en_ff2_scanout;
wire [17:11] ipd_addr_hashed_l1;
wire [17:11] ipd_addr_out_l1;
wire i_pcx_addr_pa_reg_scanin;
wire i_pcx_addr_pa_reg_scanout;
wire i_pcx_data_pa_reg_scanin;
wire i_pcx_data_pa_reg_scanout;
input tcu_se_scancollar_out;
input tcu_pce_ov; // scan signals
output [129:0] spc_pcx_data_pa;
output [8:0] spc_pcx_req_pq;
output [8:0] spc_pcx_atm_pq;
output [127:0] l15_spc_data1;
output [145:0] cpx_spc_data_cx_rep0;
output [17:0] l15_spc_cpkt;
output [8:0] pcx_spc_grant_px_buf;
input [145:0] cpx_spc_data_cx;
input [8:0] pcx_spc_grant_px;
input [39:0] ifu_l15_addr;
input [39:4] mmu_l15_addr;
input [39:0] lsu_l15_addr;
input [38:3] spu_l15_addr;
input [7:0] ifu_l15_cpkt;
input [4:0] mmu_l15_cpkt;
input [25:0] lsu_l15_cpkt;
input [12:0] spu_l15_cpkt;
input [63:0] lsu_l15_data;
input [63:0] spu_l15_data;
input ipc_sel_ndrop_ifu_l1;
input ipc_sel_ndrop_mmu_l1;
input ipc_sel_ndrop_lsu_l1;
input ipc_sel_ndrop_spu_l1;
input ipc_sel_drop_ifu_l1;
input ipc_sel_drop_mmu_l1;
input ipc_sel_drop_lsu_l1;
input ipc_sel_drop_spu_l1;
input [3:0] ipc_dropreg_wen;
input [8:0] ipc_op_req_li;
input [8:0] ipc_atm_req_li;
input ncu_spc_l2_idx_hash_en;
gkt_ipd_dp_msff_macro__stack_66c__width_3 cpuid_reg
.scan_in(cpuid_reg_scanin),
.scan_out(cpuid_reg_scanout),
.din ({const_cpuid[2:0]}),
// ISOLATION BUFFER for grant signals
gkt_ipd_dp_buff_macro__dbuff_16x__rep_1__stack_none__width_9 isolate_grant_buf
.din({pcx_spc_grant_px[8:0]}),
.dout({pcx_spc_grant_px_buf[8:0]})
// They are launched in iol2clk domain, and captured in cmp domain using sync enable
// Also since these are primary inputs to sparc core, se port is connected to scancollar_out.
// This stops the flops from capturing state during logic bist.
gkt_ipd_dp_buff_macro__dbuff_16x__rep_1__stack_none__width_6 isolate_ncu_buf
.din({ncu_spc_l2_idx_hash_en,ncu_spc_pm,ncu_spc_ba01,ncu_spc_ba23,ncu_spc_ba45,ncu_spc_ba67}),
.dout({ncu_spc_l2_idx_hash_en_buf,ncu_spc_pm_buf,ncu_spc_ba01_buf,ncu_spc_ba23_buf,ncu_spc_ba45_buf,ncu_spc_ba67_buf})
gkt_ipd_dp_msff_macro__stack_64c__width_6 i_ncu_reg
.scan_in(i_ncu_reg_scanin),
.scan_out(i_ncu_reg_scanout),
.se(tcu_se_scancollar_out),
.en (slow_cmp_sync_en_ff),
.din({ncu_spc_l2_idx_hash_en_buf,ncu_spc_pm_buf,ncu_spc_ba01_buf,ncu_spc_ba23_buf,ncu_spc_ba45_buf,ncu_spc_ba67_buf}),
.dout({idx_hash_en_ff, ncu_pm_ff, ncu_ba01_ff, ncu_ba23_ff, ncu_ba45_ff, ncu_ba67_ff}),
gkt_ipd_dp_buff_macro__dbuff_32x__rep_1__stack_none__width_4 test_rep0 (
.din ({tcu_scan_en,tcu_pce_ov,spc_aclk,spc_bclk}),
.dout({se,pce_ov,siclk,soclk})
assign mmu_l15_addr1[39:0] = {mmu_l15_addr[39:4],4'b0};
assign lsu_l15_cpkt1[25:0] = lsu_l15_cpkt[25:0];
// actual spu pkt format:
//assign spu_l15_cpkt[25] = spu_l15_valid;
//assign spu_l15_cpkt[24:21] = 4'b0010; //rqtyp
// assign spu_l15_cpkt[20] = req_type
//assign spu_l15_cpkt[19] = 1'b1; //nc
//assign spu_l15_cpkt[18:16] = cpuid[2:0]; //cpuid
//assign spu_l15_cpkt[15:13] = tid
//assign spu_l15_cpkt[12:11] = 2'b00; //inv,pf,bis
//assign spu_l15_cpkt[10] = maid
//assign spu_l15_cpkt[9:8] = 2'b00
//assign spu_l15_cpkt[7:0] = byte valids //size
assign spu_l15_cpkt1[25:0] = {spu_l15_valid, 4'b0010, spu_l15_cpkt[4], 1'b1, cpuid[2:0], spu_l15_cpkt[2:0], 2'b0, spu_l15_cpkt[3], 2'b0, spu_l15_cpkt[12:5]};
assign spu_l15_addr1[39:0] = {1'b0, spu_l15_addr[38:3], 3'b000};
// actual mmu pkt format:
//assign mmu_l15_cpkt[25] = mmu_l15_valid;
//assign mmu_l15_cpkt[24:20] = 5'b01000; //rqtyp
//assign mmu_l15_cpkt[19] = 1'b1; //nc
//assign mmu_l15_cpkt[18:16] = cpuid[2:0]; //cpuid
//assign mmu_l15_cpkt[15:13] = tid
//assign mmu_l15_cpkt[12:10] = 3'b000; //inv,pf,bis
//assign mmu_l15_cpkt[9:7] = mmuid
//assign mmu_l15_cpkt[7:0] = 8'b0; //size
assign mmu_l15_cpkt1[25:0] = {mmu_l15_valid,5'b01000,1'b1,cpuid[2:0],mmu_l15_cpkt[2:0],3'b0,mmu_l15_cpkt[4:3],8'b0};
// Actual ifu_l15_cpkt has following fields
// ifu_l15_cpkt[25] = ifu_l15_valid
// ifu_l15_cpkt[24:20] = ifu_l15_req_type[4:0] = 5'b10000
// ifu_l15_cpkt[19] = ifu_l15_nc
// ifu_l15_cpkt[18:16] = ifu_l15_cpuid[2:0]
// ifu_l15_cpkt[15:13] = ifu_l15_tid[2:0]
// ifu_l15_cpkt[12] = ifu_l15_inv
// ifu_l15_cpkt[11] = ifu_l15_pf = 0
// ifu_l15_cpkt[10:8] = ifu_l15_rway[2:0]
// ifu_l15_cpkt[7:0] = ifu_l15_size[7:0] = 0
assign ifu_l15_cpkt1[25:0] = {ifu_l15_valid,5'b10000,ifu_l15_cpkt[7],cpuid[2:0],
ifu_l15_cpkt[2:0],ifu_l15_cpkt[6],1'b0,ifu_l15_cpkt[5:3],8'b0};
///////////////////////////////////////////////////////////////////
// PIPE the CPX data and cpkt to SPARC core
// Also since these are primary inputs to sparc core, se port is connected to scancollar_out.
// This stops the flops from capturing state during logic bist.
///////////////////////////////////////////////////////////////////
gkt_ipd_dp_buff_macro__dbuff_48x__rep_1__stack_64c__width_64 gkt_lsu_datalo_rep0 (
.din (cpx_spc_data_cx[63:0]),
.dout(cpx_spc_data_cx_rep0[63:0])
gkt_ipd_dp_msff_macro__stack_64c__width_64 i_cpx_data1lo_reg
.scan_in(i_cpx_data1lo_reg_scanin),
.scan_out(i_cpx_data1lo_reg_scanout),
.se(tcu_se_scancollar_out),
.din(cpx_spc_data_cx_rep0[63:0]),
.dout(l15_spc_data[63:0]),
gkt_ipd_dp_buff_macro__dbuff_48x__rep_1__stack_64c__width_64 i_buf_data1lo_spc (
.din (l15_spc_data[63:0]),
.dout (l15_spc_data1[63:0])
gkt_ipd_dp_buff_macro__dbuff_48x__rep_1__stack_64c__width_64 gkt_lsu_datahi_rep0 (
.din (cpx_spc_data_cx[127:64]),
.dout(cpx_spc_data_cx_rep0[127:64])
gkt_ipd_dp_msff_macro__stack_64c__width_64 i_cpx_data1hi_reg
.scan_in(i_cpx_data1hi_reg_scanin),
.scan_out(i_cpx_data1hi_reg_scanout),
.se(tcu_se_scancollar_out),
.din(cpx_spc_data_cx_rep0[127:64]),
.dout(l15_spc_data[127:64]),
gkt_ipd_dp_buff_macro__dbuff_48x__rep_1__stack_64c__width_64 i_buf_data1hi_spc (
.din (l15_spc_data[127:64]),
.dout (l15_spc_data1[127:64])
gkt_ipd_dp_buff_macro__dbuff_48x__rep_1__stack_none__width_18 gkt_lsu_cpkt_rep0 (
.din (cpx_spc_data_cx[145:128]),
.dout(cpx_spc_data_cx_rep0[145:128])
gkt_ipd_dp_msff_macro__stack_64c__width_18 i_cpx_cpkt_reg
.scan_in(i_cpx_cpkt_reg_scanin),
.scan_out(i_cpx_cpkt_reg_scanout),
.se(tcu_se_scancollar_out),
.din({cpx_spc_data_cx_rep0[145:128]}),
.dout({l15_spc_data[145:128]}),
assign cpx_cpkt[18:0] = {l15_spc_data[145:140],1'b0,l15_spc_data[139:128]};
gkt_ipd_dp_buff_macro__dbuff_32x__rep_1__stack_none__width_20 i_buf_cpkt_spc (
.din ({cpx_cpkt[18],cpx_cpkt[18:0]}),
.dout ({l15_spu_valid,l15_mmu_valid,l15_spc_cpkt[17:0]})
///////////////////////////////////////////////////////////////////
// Generate request and atomic signals going to PCX
///////////////////////////////////////////////////////////////////
//assign op_req[8:0] = ({9{req_dropped_lat}} & req_repeat_drop_l1[8:0]) |
// ({9{req_dropped_lat_}} & req_repeat_ndrop_l1[8:0]) |
// (req_nrepeat_drop_l1[8:0]) |
// (req_nrepeat_ndrop_l1[8:0]);
//assign spc_pcx_req_pq[8:0] = op_req[8:0] & {9{~core_isolate}};
// flop op_req_li and atm_req_li
gkt_ipd_dp_msff_macro__dmsff_8x__stack_64c__width_19 i_req_li_reg
.scan_in(i_req_li_reg_scanin),
.scan_out(i_req_li_reg_scanout),
.din({slow_cmp_sync_en,ipc_op_req_li[8:0],ipc_atm_req_li[8:0]}),
.dout({slow_cmp_sync_en_ff, op_req[8:0], atm_req[8:0]}),
gkt_ipd_dp_inv_macro__dinv_8x__stack_64c__width_1 i_clk_stop_inv (
gkt_ipd_dp_nand_macro__dnand_16x__ports_2__stack_64c__width_9 i_pcx_req_nand_w9
.din1({9{core_isolate_}}),
gkt_ipd_dp_inv_macro__dinv_48x__stack_64c__width_9 i_pcx_req_inv_w9
.din({pcx_req_pq_[8:0]}),
.dout({spc_pcx_req_pq[8:0]})
//assign atm_req[8:0] = {9{~ipc_dropreg_valid[2]}} & ipc_atm_l1[8:0];
//assign spc_pcx_atm_pq[8:0] = atm_req[8:0] & {9{~core_isolate}};
gkt_ipd_dp_nand_macro__dnand_16x__ports_2__stack_64c__width_9 i_atm_nand (
.din1 ({9{core_isolate_}}),
gkt_ipd_dp_inv_macro__dinv_48x__stack_64c__width_9 i_pcx_atm_inv_w9
.din({pcx_atm_pq_[8:0]}),
.dout({spc_pcx_atm_pq[8:0]})
// assertion, atomic request cannot be asserted without valid request
/* 0in assert -var (~(|(spc_pcx_atm_pq[8:0] & ~(spc_pcx_req_pq[8:0]))))
-message "l15_ipc_ctl: spc_pcx_atm_pq asserted without spc_pcx_req_pq" */
///////////////////////////////////////////////////////////////////
// Latch ifu pkt in 2-entry FIFO
///////////////////////////////////////////////////////////////////
gkt_ipd_dp_msff_macro__mux_aonpe__ports_2__stack_66c__width_66 i_ifu_addr_v1_muxreg
.scan_in(i_ifu_addr_v1_muxreg_scanin),
.scan_out(i_ifu_addr_v1_muxreg_scanout),
.din0({ifu_l15_cpkt1[25:0],ifu_l15_addr[39:0]}),
.din1({v1_ifu_cpkt[25:0],v1_ifu_addr[39:0]}),
.dout({v1_ifu_cpkt[25:0],v1_ifu_addr[39:0]}),
gkt_ipd_dp_msff_macro__mux_aonpe__ports_3__stack_66c__width_66 i_ifu_addr_v0_muxreg
.scan_in(i_ifu_addr_v0_muxreg_scanin),
.scan_out(i_ifu_addr_v0_muxreg_scanout),
.din0({ifu_l15_cpkt1[25:0],ifu_l15_addr[39:0]}),
.din1({v1_ifu_cpkt[25:0],v1_ifu_addr[39:0]}),
.din2({v0_ifu_cpkt[25:0],v0_ifu_addr[39:0]}),
.dout({v0_ifu_cpkt[25:0],v0_ifu_addr[39:0]}),
///////////////////////////////////////////////////////////////////
// Latch mmu pkt in 2-entry FIFO
///////////////////////////////////////////////////////////////////
gkt_ipd_dp_msff_macro__mux_aonpe__ports_2__stack_66c__width_66 i_mmu_addr_v1_muxreg
.scan_in(i_mmu_addr_v1_muxreg_scanin),
.scan_out(i_mmu_addr_v1_muxreg_scanout),
.din0({mmu_l15_cpkt1[25:0],mmu_l15_addr1[39:0]}),
.din1({v1_mmu_cpkt[25:0],v1_mmu_addr[39:0]}),
.dout({v1_mmu_cpkt[25:0],v1_mmu_addr[39:0]}),
gkt_ipd_dp_msff_macro__mux_aonpe__ports_3__stack_66c__width_66 i_mmu_addr_v0_muxreg
.scan_in(i_mmu_addr_v0_muxreg_scanin),
.scan_out(i_mmu_addr_v0_muxreg_scanout),
.din0({mmu_l15_cpkt1[25:0],mmu_l15_addr1[39:0]}),
.din1({v1_mmu_cpkt[25:0],v1_mmu_addr[39:0]}),
.din2({v0_mmu_cpkt[25:0],v0_mmu_addr[39:0]}),
.dout({v0_mmu_cpkt[25:0],v0_mmu_addr[39:0]}),
///////////////////////////////////////////////////////////////////
// Latch lsu pkt in 2-entry FIFO
///////////////////////////////////////////////////////////////////
gkt_ipd_dp_msff_macro__mux_aonpe__ports_2__stack_66c__width_66 i_lsu_addr_v1_muxreg
.scan_in(i_lsu_addr_v1_muxreg_scanin),
.scan_out(i_lsu_addr_v1_muxreg_scanout),
.din0({lsu_l15_cpkt1[25:0],lsu_l15_addr[39:0]}),
.din1({v1_lsu_cpkt[25:0],v1_lsu_addr[39:0]}),
.dout({v1_lsu_cpkt[25:0],v1_lsu_addr[39:0]}),
gkt_ipd_dp_msff_macro__mux_aonpe__ports_3__stack_66c__width_66 i_lsu_addr_v0_muxreg
.scan_in(i_lsu_addr_v0_muxreg_scanin),
.scan_out(i_lsu_addr_v0_muxreg_scanout),
.din0({lsu_l15_cpkt1[25:0],lsu_l15_addr[39:0]}),
.din1({v1_lsu_cpkt[25:0],v1_lsu_addr[39:0]}),
.din2({v0_lsu_cpkt[25:0],v0_lsu_addr[39:0]}),
.dout({v0_lsu_cpkt[25:0],v0_lsu_addr[39:0]}),
gkt_ipd_dp_msff_macro__mux_aonpe__ports_2__stack_64c__width_64 i_lsu_data_v1_muxreg
.scan_in(i_lsu_data_v1_muxreg_scanin),
.scan_out(i_lsu_data_v1_muxreg_scanout),
.din0(lsu_l15_data[63:0]),
.din1(v1_lsu_data[63:0]),
.dout(v1_lsu_data[63:0]),
gkt_ipd_dp_msff_macro__mux_aonpe__ports_3__stack_64c__width_64 i_lsu_data_v0_muxreg
.scan_in(i_lsu_data_v0_muxreg_scanin),
.scan_out(i_lsu_data_v0_muxreg_scanout),
.din0(lsu_l15_data[63:0]),
.din1(v1_lsu_data[63:0]),
.din2(v0_lsu_data[63:0]),
.dout(v0_lsu_data[63:0]),
///////////////////////////////////////////////////////////////////
// Latch spu pkt in 2-entry FIFO
///////////////////////////////////////////////////////////////////
gkt_ipd_dp_msff_macro__mux_aonpe__ports_2__stack_66c__width_66 i_spu_addr_v1_muxreg
.scan_in(i_spu_addr_v1_muxreg_scanin),
.scan_out(i_spu_addr_v1_muxreg_scanout),
.din0({spu_l15_cpkt1[25:0],spu_l15_addr1[39:0]}),
.din1({v1_spu_cpkt[25:0],v1_spu_addr[39:0]}),
.dout({v1_spu_cpkt[25:0],v1_spu_addr[39:0]}),
gkt_ipd_dp_msff_macro__mux_aonpe__ports_3__stack_66c__width_66 i_spu_addr_v0_muxreg
.scan_in(i_spu_addr_v0_muxreg_scanin),
.scan_out(i_spu_addr_v0_muxreg_scanout),
.din0({spu_l15_cpkt1[25:0],spu_l15_addr1[39:0]}),
.din1({v1_spu_cpkt[25:0],v1_spu_addr[39:0]}),
.din2({v0_spu_cpkt[25:0],v0_spu_addr[39:0]}),
.dout({v0_spu_cpkt[25:0],v0_spu_addr[39:0]}),
gkt_ipd_dp_msff_macro__mux_aonpe__ports_2__stack_64c__width_64 i_spu_data_v1_muxreg
.scan_in(i_spu_data_v1_muxreg_scanin),
.scan_out(i_spu_data_v1_muxreg_scanout),
.din0(spu_l15_data[63:0]),
.din1(v1_spu_data[63:0]),
.dout(v1_spu_data[63:0]),
gkt_ipd_dp_msff_macro__mux_aonpe__ports_3__stack_64c__width_64 i_spu_data_v0_muxreg
.scan_in(i_spu_data_v0_muxreg_scanin),
.scan_out(i_spu_data_v0_muxreg_scanout),
.din0(spu_l15_data[63:0]),
.din1(v1_spu_data[63:0]),
.din2(v0_spu_data[63:0]),
.dout(v0_spu_data[63:0]),
///////////////////////////////////////////////////////////////////
// L1/PQ cycle. Mux the pcx packets from all sources and corresponding
///////////////////////////////////////////////////////////////////
// save Muxed data into drop registers
gkt_ipd_dp_msff_macro__stack_66c__width_66 i_ifu_addr_drop_reg
.scan_in(i_ifu_addr_drop_reg_scanin),
.scan_out(i_ifu_addr_drop_reg_scanout),
.en (ipc_dropreg_wen[0]),
.din({ipd_cpkt_l1[25:0],ipd_addr_l1[39:0]}),
.dout({drop_ifu_cpkt[25:0],drop_ifu_addr[39:0]}),
gkt_ipd_dp_msff_macro__stack_66c__width_66 i_mmu_addr_drop_reg
.scan_in(i_mmu_addr_drop_reg_scanin),
.scan_out(i_mmu_addr_drop_reg_scanout),
.en (ipc_dropreg_wen[1]),
.din({ipd_cpkt_l1[25:0],ipd_addr_l1[39:0]}),
.dout({drop_mmu_cpkt[25:0],drop_mmu_addr[39:0]}),
gkt_ipd_dp_msff_macro__stack_66c__width_66 i_lsu_addr_drop_reg
.scan_in(i_lsu_addr_drop_reg_scanin),
.scan_out(i_lsu_addr_drop_reg_scanout),
.en (ipc_dropreg_wen[2]),
.din({ipd_cpkt_l1[25:0],ipd_addr_l1[39:0]}),
.dout({drop_lsu_cpkt[25:0],drop_lsu_addr[39:0]}),
gkt_ipd_dp_msff_macro__stack_66c__width_66 i_spu_addr_drop_reg
.scan_in(i_spu_addr_drop_reg_scanin),
.scan_out(i_spu_addr_drop_reg_scanout),
.en (ipc_dropreg_wen[3]),
.din({ipd_cpkt_l1[25:0],ipd_addr_l1[39:0]}),
.dout({drop_spu_cpkt[25:0],drop_spu_addr[39:0]}),
gkt_ipd_dp_msff_macro__stack_64c__width_64 i_lsu_data_drop_reg
.scan_in(i_lsu_data_drop_reg_scanin),
.scan_out(i_lsu_data_drop_reg_scanout),
.en (ipc_dropreg_wen[2]),
.dout(drop_lsu_data[63:0]),
gkt_ipd_dp_msff_macro__stack_64c__width_64 i_spu_data_drop_reg
.scan_in(i_spu_data_drop_reg_scanin),
.scan_out(i_spu_data_drop_reg_scanout),
.en (ipc_dropreg_wen[3]),
.dout(drop_spu_data[63:0]),
// MUX the PCX packet out
gkt_ipd_dp_mux_macro__mux_aonpe__ports_8__stack_66c__width_66 i_l1_addr_mux
.din0({v0_ifu_cpkt[25:0],v0_ifu_addr[39:0]}),
.din1({v0_mmu_cpkt[25:0],v0_mmu_addr[39:0]}),
.din2({v0_lsu_cpkt[25:0],v0_lsu_addr[39:0]}),
.din3({v0_spu_cpkt[25:0],v0_spu_addr[39:0]}),
.din4({drop_ifu_cpkt[25:0],drop_ifu_addr[39:0]}),
.din5({drop_mmu_cpkt[25:0],drop_mmu_addr[39:0]}),
.din6({drop_lsu_cpkt[25:0],drop_lsu_addr[39:0]}),
.din7({drop_spu_cpkt[25:0],drop_spu_addr[39:0]}),
.sel0(ipc_sel_ndrop_ifu_l1),
.sel1(ipc_sel_ndrop_mmu_l1),
.sel2(ipc_sel_ndrop_lsu_l1),
.sel3(ipc_sel_ndrop_spu_l1),
.sel4(ipc_sel_drop_ifu_l1),
.sel5(ipc_sel_drop_mmu_l1),
.sel6(ipc_sel_drop_lsu_l1),
.sel7(ipc_sel_drop_spu_l1),
.dout({ipd_cpkt_l1[25:0],ipd_addr_l1_prebuf[39:0]})
gkt_ipd_dp_buff_macro__stack_66c__width_40 i_l1_addr_buf
.din ({ipd_addr_l1_prebuf[39:0]}),
.dout({ipd_addr_l1[39:0]})
// IF Address Hashing is enabled and Bit 39 of the address is not set (not an I/O,
// or L2 diagnostic access) then hash the addresses in following manner:
//PA[17:11] = {(PA[32:28] ^ PA[17:13]), (PA[19:18] ^ PA[12:11])}
// enable_hash = lsu_hash_en & ~PA[39]
// = ~(~lsu_hash_en | PA[39])
gkt_ipd_dp_msff_macro__stack_64c__width_1 i_hash_en_ff2
.scan_in(i_hash_en_ff2_scanin),
.scan_out(i_hash_en_ff2_scanout),
gkt_ipd_dp_inv_macro__stack_64c__width_1 i_hash_en_inv
gkt_ipd_dp_nor_macro__stack_66c__width_1 i_enable_hash_nor
gkt_ipd_dp_xor_macro__ports_2__stack_66c__width_7 i_l1_hash_xor
.din0({ipd_addr_l1[32:28],ipd_addr_l1[19:18]}),
.din1({ipd_addr_l1[17:13],ipd_addr_l1[12:11]}),
.dout(ipd_addr_hashed_l1[17:11])
gkt_ipd_dp_mux_macro__mux_aope__ports_2__stack_66c__width_7 i_l1_hash_mux
.din0(ipd_addr_hashed_l1[17:11]),
.din1(ipd_addr_l1[17:11]),
.dout(ipd_addr_out_l1[17:11])
// mux the store data out
gkt_ipd_dp_mux_macro__mux_aonpe__ports_4__stack_64c__width_64 i_l1_data_mux
.din0(v0_lsu_data[63:0]),
.din1(v0_spu_data[63:0]),
.din2(drop_lsu_data[63:0]),
.din3(drop_spu_data[63:0]),
.sel0(ipc_sel_ndrop_lsu_l1),
.sel1(ipc_sel_ndrop_spu_l1),
.sel2(ipc_sel_drop_lsu_l1),
.sel3(ipc_sel_drop_spu_l1),
// pipe the data out to PCX in PA
gkt_ipd_dp_msff_macro__dmsff_8x__stack_66c__width_66 i_pcx_addr_pa_reg
.scan_in(i_pcx_addr_pa_reg_scanin),
.scan_out(i_pcx_addr_pa_reg_scanout),
.din({ipd_cpkt_l1[25:0],ipd_addr_l1[39:18],ipd_addr_out_l1[17:11],ipd_addr_l1[10:0]}),
.dout({pcx_cpkt_pa[25:0],pcx_addr_pa[39:0]}),
gkt_ipd_dp_buff_macro__dbuff_32x__rep_1__stack_66c__width_66 i_pcx_addr_buf
.din({pcx_cpkt_pa[25:0],pcx_addr_pa[39:0]}),
.dout({spc_pcx_data_pa[129:64]})
gkt_ipd_dp_buff_macro__stack_none__width_9 i_optype_buf
.din({pcx_cpkt_pa[10],pcx_cpkt_pa[24:20],pcx_cpkt_pa[15:13]}),
gkt_ipd_dp_msff_macro__dmsff_8x__stack_64c__width_64 i_pcx_data_pa_reg
.scan_in(i_pcx_data_pa_reg_scanin),
.scan_out(i_pcx_data_pa_reg_scanout),
.dout(pcx_data_pa[63:0]),
gkt_ipd_dp_buff_macro__dbuff_32x__rep_1__stack_64c__width_64 i_pcx_data_buf
.dout(spc_pcx_data_pa[63:0])
assign cpuid_reg_scanin = scan_in ;
assign i_ncu_reg_scanin = cpuid_reg_scanout ;
assign i_cpx_data1lo_reg_scanin = i_ncu_reg_scanout ;
assign i_cpx_data1hi_reg_scanin = i_cpx_data1lo_reg_scanout;
assign i_cpx_cpkt_reg_scanin = i_cpx_data1hi_reg_scanout;
assign i_req_li_reg_scanin = i_cpx_cpkt_reg_scanout ;
assign i_ifu_addr_v1_muxreg_scanin = i_req_li_reg_scanout ;
assign i_ifu_addr_v0_muxreg_scanin = i_ifu_addr_v1_muxreg_scanout;
assign i_mmu_addr_v1_muxreg_scanin = i_ifu_addr_v0_muxreg_scanout;
assign i_mmu_addr_v0_muxreg_scanin = i_mmu_addr_v1_muxreg_scanout;
assign i_lsu_addr_v1_muxreg_scanin = i_mmu_addr_v0_muxreg_scanout;
assign i_lsu_addr_v0_muxreg_scanin = i_lsu_addr_v1_muxreg_scanout;
assign i_lsu_data_v1_muxreg_scanin = i_lsu_addr_v0_muxreg_scanout;
assign i_lsu_data_v0_muxreg_scanin = i_lsu_data_v1_muxreg_scanout;
assign i_spu_addr_v1_muxreg_scanin = i_lsu_data_v0_muxreg_scanout;
assign i_spu_addr_v0_muxreg_scanin = i_spu_addr_v1_muxreg_scanout;
assign i_spu_data_v1_muxreg_scanin = i_spu_addr_v0_muxreg_scanout;
assign i_spu_data_v0_muxreg_scanin = i_spu_data_v1_muxreg_scanout;
assign i_ifu_addr_drop_reg_scanin = i_spu_data_v0_muxreg_scanout;
assign i_mmu_addr_drop_reg_scanin = i_ifu_addr_drop_reg_scanout;
assign i_lsu_addr_drop_reg_scanin = i_mmu_addr_drop_reg_scanout;
assign i_spu_addr_drop_reg_scanin = i_lsu_addr_drop_reg_scanout;
assign i_lsu_data_drop_reg_scanin = i_spu_addr_drop_reg_scanout;
assign i_spu_data_drop_reg_scanin = i_lsu_data_drop_reg_scanout;
assign i_hash_en_ff2_scanin = i_spu_data_drop_reg_scanout;
assign i_pcx_addr_pa_reg_scanin = i_hash_en_ff2_scanout ;
assign i_pcx_data_pa_reg_scanin = i_pcx_addr_pa_reg_scanout;
assign scan_out = i_pcx_data_pa_reg_scanout;
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_msff_macro__stack_66c__width_3 (
module gkt_ipd_dp_buff_macro__dbuff_16x__rep_1__stack_none__width_9 (
module gkt_ipd_dp_buff_macro__dbuff_16x__rep_1__stack_none__width_6 (
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_msff_macro__stack_64c__width_6 (
module gkt_ipd_dp_buff_macro__dbuff_32x__rep_1__stack_none__width_4 (
module gkt_ipd_dp_buff_macro__dbuff_48x__rep_1__stack_64c__width_64 (
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_msff_macro__stack_64c__width_64 (
.so({so[62:0],scan_out}),
module gkt_ipd_dp_buff_macro__dbuff_48x__rep_1__stack_none__width_18 (
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_msff_macro__stack_64c__width_18 (
.so({so[16:0],scan_out}),
module gkt_ipd_dp_buff_macro__dbuff_32x__rep_1__stack_none__width_20 (
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_msff_macro__dmsff_8x__stack_64c__width_19 (
.so({so[17:0],scan_out}),
module gkt_ipd_dp_inv_macro__dinv_8x__stack_64c__width_1 (
// nand macro for ports = 2,3,4
module gkt_ipd_dp_nand_macro__dnand_16x__ports_2__stack_64c__width_9 (
module gkt_ipd_dp_inv_macro__dinv_48x__stack_64c__width_9 (
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_msff_macro__mux_aonpe__ports_2__stack_66c__width_66 (
cl_dp1_muxbuff2_8x c1_0 (
.so({so[64:0],scan_out}),
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_msff_macro__mux_aonpe__ports_3__stack_66c__width_66 (
cl_dp1_muxbuff3_8x c1_0 (
.so({so[64:0],scan_out}),
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_msff_macro__mux_aonpe__ports_2__stack_64c__width_64 (
cl_dp1_muxbuff2_8x c1_0 (
.so({so[62:0],scan_out}),
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_msff_macro__mux_aonpe__ports_3__stack_64c__width_64 (
cl_dp1_muxbuff3_8x c1_0 (
.so({so[62:0],scan_out}),
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_msff_macro__stack_66c__width_66 (
.so({so[64:0],scan_out}),
// general mux macro for pass-gate and and-or muxes with/wout priority encoders
// also for pass-gate with decoder
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_mux_macro__mux_aonpe__ports_8__stack_66c__width_66 (
cl_dp1_muxbuff8_8x c0_0 (
module gkt_ipd_dp_buff_macro__stack_66c__width_40 (
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_msff_macro__stack_64c__width_1 (
module gkt_ipd_dp_inv_macro__stack_64c__width_1 (
// nor macro for ports = 2,3
module gkt_ipd_dp_nor_macro__stack_66c__width_1 (
// xor macro for ports = 2,3
module gkt_ipd_dp_xor_macro__ports_2__stack_66c__width_7 (
// general mux macro for pass-gate and and-or muxes with/wout priority encoders
// also for pass-gate with decoder
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_mux_macro__mux_aope__ports_2__stack_66c__width_7 (
// general mux macro for pass-gate and and-or muxes with/wout priority encoders
// also for pass-gate with decoder
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_mux_macro__mux_aonpe__ports_4__stack_64c__width_64 (
cl_dp1_muxbuff4_8x c0_0 (
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_msff_macro__dmsff_8x__stack_66c__width_66 (
.so({so[64:0],scan_out}),
module gkt_ipd_dp_buff_macro__dbuff_32x__rep_1__stack_66c__width_66 (
module gkt_ipd_dp_buff_macro__stack_none__width_9 (
// any PARAMS parms go into naming of macro
module gkt_ipd_dp_msff_macro__dmsff_8x__stack_64c__width_64 (
.so({so[62:0],scan_out}),
module gkt_ipd_dp_buff_macro__dbuff_32x__rep_1__stack_64c__width_64 (