// ========== Copyright Header Begin ==========================================
// OpenSPARC T2 Processor File: spc_mb2_ctl.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 input_signals_reg_scanin;
wire input_signals_reg_scanout;
wire mb_enable_reg_scanin;
wire mb_enable_reg_scanout;
wire loop_again_reg_scanin;
wire loop_again_reg_scanout;
wire array_usr_reg_scanin;
wire array_usr_reg_scanout;
wire [3:0] user_array_in;
wire user_addr_mode_reg_scanin;
wire user_addr_mode_reg_scanout;
wire user_start_addr_reg_scanin;
wire user_start_addr_reg_scanout;
wire [9:0] user_start_addr_in;
wire [9:0] user_start_addr;
wire user_stop_addr_reg_scanin;
wire user_stop_addr_reg_scanout;
wire [9:0] user_stop_addr_in;
wire [9:0] user_stop_addr;
wire user_incr_addr_reg_scanin;
wire user_incr_addr_reg_scanout;
wire [9:0] user_incr_addr_in;
wire [9:0] user_incr_addr;
wire user_data_mode_reg_scanin;
wire user_data_mode_reg_scanout;
wire user_data_reg_scanin;
wire user_data_reg_scanout;
wire user_cmpselinc_hold_reg_scanin;
wire user_cmpselinc_hold_reg_scanout;
wire user_cmpselinc_hold_in;
wire user_cmpselinc_hold;
wire user_cmpsel_reg_scanin;
wire user_cmpsel_reg_scanout;
wire [2:0] user_cmpsel_in;
wire user_loop_mode_reg_scanin;
wire user_loop_mode_reg_scanout;
wire ten_n_mode_reg_scanin;
wire ten_n_mode_reg_scanout;
wire user_bisi_wr_mode_reg_scanin;
wire user_bisi_wr_mode_reg_scanout;
wire user_bisi_wr_mode_in;
wire user_bisi_rd_mode_reg_scanin;
wire user_bisi_rd_mode_reg_scanout;
wire user_bisi_rd_mode_in;
wire mb_user_cmpselinc_hold;
wire mb_user_bisi_wr_mode;
wire mb_user_bisi_rd_mode;
wire mb_user_bisi_rw_mode;
wire [3:0] march_element;
wire [3:0] cntl_array_sel;
wire [2:0] cmp_sel_cntl_out;
wire cmp_sel_reg_scanout;
wire [1:0] cntl_data_sel;
wire [3:0] cntl_march_element;
wire sel_nextaddr_restart;
wire sel_nextaddr_incred;
wire [3:0] march_element_pre;
wire [3:0] array_sel_cntl_out;
wire array_sel_reg_scanin;
wire array_sel_reg_scanout;
wire [3:0] array_sel_out;
wire [3:0] march_element_cntl_out;
wire marche_element_reg_scanin;
wire marche_element_reg_scanout;
wire [3:0] march_element_out;
wire [7:0] mb_write_data;
wire spu_arf_fail_sticky;
wire spu_rrf_fail_sticky;
wire spu_mam_fail_sticky;
wire exu0_irf_fail_sticky;
wire exu1_irf_fail_sticky;
wire fgu_frf_fail_sticky;
wire run3_transition_reg_scanin;
wire run3_transition_reg_scanout;
wire done_delay_reg_scanin;
wire done_delay_reg_scanout;
wire [4:0] done_delay_in;
wire out_run_mb_arrays_reg_scanin;
wire out_run_mb_arrays_reg_scanout;
wire out_data_mb_arrays_reg_scanin;
wire out_data_mb_arrays_reg_scanout;
wire [7:0] mb_write_data_out;
wire out_addr_mb_arrays_reg_scanin;
wire out_addr_mb_arrays_reg_scanout;
wire out_wr_mb_arrays_reg_scanin;
wire out_wr_mb_arrays_reg_scanout;
wire out_rd_mb_arrays_reg_scanin;
wire out_rd_mb_arrays_reg_scanout;
wire out_mb_tcu_done_reg_scanin;
wire out_mb_tcu_done_reg_scanout;
wire out_mb_tcu_fail_reg_scanin;
wire out_mb_tcu_fail_reg_scanout;
wire i_delay_4th_scanout;
wire delayed_cmp_rd_data_reg_scanin;
wire delayed_cmp_rd_data_reg_scanout;
wire out_save_restore_mb_arrays_reg_scanin;
wire out_save_restore_mb_arrays_reg_scanout;
// /////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////
output mb2_irf_restore_en;
output [7:0] mb2_write_data;
output [7:0] mb2_write_data_p1;
output [7:0] mb2_write_data_p2;
// /////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////
input tcu_pce_ov; // scan signals
input lsu_misc_pmen; // Power management enable
input spu_mbi_mam_fail_; // MBIST comparator output bits 63:0
input spu_mbi_mam_fail2_; // MBIST comparator output bits 71:64
input spu_mbi_arf_fail_; // MBIST comparator
input spu_mbi_rrf_fail_; // MBIST comparator
input [1:0] exu0_mbi_irf_fail_; // MBIST [0] == data[63:0]; [1] == data[71:64]
input [1:0] exu1_mbi_irf_fail_; // MBIST [0] == data[63:0]; [1] == data[71:64]
supply0 vss; // <- port for ground
supply1 vdd; // <- port for power
// /////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////
assign pce_ov = tcu_pce_ov;
assign stop = tcu_clk_stop;
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
spc_mb2_ctll1clkhdr_ctl_macro clkgen (
spc_mb2_ctlmsff_ctl_macro__width_3 pmen (
.l1clk ( l1clk ), // Must be connected to a free running clock
.din ({mbist_start, ~lsu_misc_pmen , 1'b0} ),
.dout ({start_in , misc_pmen_ , pmem_unused} ),
assign mb2_misc_pmen = ~misc_pmen_; // Sent to MB1 for timing reasons
assign clock_enable = start_in | mb2_done | mb2_run | mb2_mbist_fail | misc_pmen_;
spc_mb2_ctll1clkhdr_ctl_macro clkgen_pm1 (
// /////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////
// A low to high transition on mbist_start will reset and start the engine.
// mbist_start must remain active high for the duration of MBIST.
// If mbist_start deasserts the engine will stop but not reset.
// Once MBIST has completed mb0_done will assert and the fail status
// signals will be valid.
// To run MBIST again the mbist_start signal must transition low then high.
// Loop on Address will disable the address mix function.
// /////////////////////////////////////////////////////////////////////////////
// flop incoming signals:
spc_mb2_ctlmsff_ctl_macro__width_2 input_signals_reg (
.scan_in(input_signals_reg_scanin),
.scan_out(input_signals_reg_scanout),
.din ( {mbist_bisi_mode,mbist_user_mode} ),
.dout ( {bisi_mode ,user_mode} ),
// user_mode : mb_enable=depend on programmed value
spc_mb2_ctlmsff_ctl_macro__width_1 mb_enable_reg (
.scan_in(mb_enable_reg_scanin),
.scan_out(mb_enable_reg_scanout),
//assign mb_enable = user_mode ? mb_enable_out : 1'b0;
assign mb_enable = mb_enable_out;
assign start = user_mode ? (mb_enable_out & start_in) :
spc_mb2_ctlmsff_ctl_macro__width_2 config_reg (
.scan_in(config_reg_scanin),
.scan_out(config_reg_scanout),
.dout ( config_out[1:0] ),
assign config_in[0] = start;
assign config_in[1] = config_out[0];
assign start_transition = config_out[0] & ~config_out[1];
assign end_transition = ~config_out[0] & config_out[1];
assign reset_engine = start_transition | loop_again | end_transition;
assign run = config_out[1];
spc_mb2_ctlmsff_ctl_macro__width_1 loop_again_reg (
.scan_in(loop_again_reg_scanin),
.scan_out(loop_again_reg_scanout),
.dout ( stop_engine_l_q ),
assign loop_again=mb_user_loop_mode ? stop_engine_l & ~stop_engine_l_q: 1'b0;
////////////////////////////////////////////////////////////////////////////////
// user control registers
// - user_cmpselinc_mode 1
////////////////////////////////////////////////////////////////////////////////
spc_mb2_ctlmsff_ctl_macro__width_4 array_usr_reg (
.scan_in(array_usr_reg_scanin),
.scan_out(array_usr_reg_scanout),
.din ( user_array_in[3:0] ),
.dout ( user_array[3:0] ),
assign user_array_in[3:0]=user_array[3:0];
spc_mb2_ctlmsff_ctl_macro__width_1 user_addr_mode_reg (
.scan_in(user_addr_mode_reg_scanin),
.scan_out(user_addr_mode_reg_scanout),
.din ( user_addr_mode_in ),
.dout ( user_addr_mode ),
assign user_addr_mode_in=user_addr_mode;
spc_mb2_ctlmsff_ctl_macro__width_10 user_start_addr_reg (
.scan_in(user_start_addr_reg_scanin),
.scan_out(user_start_addr_reg_scanout),
.din ( user_start_addr_in[9:0] ),
.dout ( user_start_addr[9:0] ),
assign user_start_addr_in[9:0]=user_start_addr[9:0];
spc_mb2_ctlmsff_ctl_macro__width_10 user_stop_addr_reg (
.scan_in(user_stop_addr_reg_scanin),
.scan_out(user_stop_addr_reg_scanout),
.din ( user_stop_addr_in[9:0] ),
.dout ( user_stop_addr[9:0] ),
assign user_stop_addr_in[9:0]=user_stop_addr[9:0];
// user increment address
spc_mb2_ctlmsff_ctl_macro__width_10 user_incr_addr_reg (
.scan_in(user_incr_addr_reg_scanin),
.scan_out(user_incr_addr_reg_scanout),
.din ( user_incr_addr_in[9:0] ),
.dout ( user_incr_addr[9:0] ),
assign user_incr_addr_in[9:0]=user_incr_addr[9:0];
spc_mb2_ctlmsff_ctl_macro__width_1 user_data_mode_reg (
.scan_in(user_data_mode_reg_scanin),
.scan_out(user_data_mode_reg_scanout),
.din ( user_data_mode_in ),
.dout ( user_data_mode ),
assign user_data_mode_in=user_data_mode;
spc_mb2_ctlmsff_ctl_macro__width_8 user_data_reg (
.scan_in(user_data_reg_scanin),
.scan_out(user_data_reg_scanout),
.din ( user_data_in[7:0] ),
.dout ( user_data[7:0] ),
assign user_data_in[7:0] = user_data[7:0];
// if its one, user need to program the cmpselinc register
// otherwise it will loop all cmpsel
spc_mb2_ctlmsff_ctl_macro__width_1 user_cmpselinc_hold_reg (
.scan_in(user_cmpselinc_hold_reg_scanin),
.scan_out(user_cmpselinc_hold_reg_scanout),
.din ( user_cmpselinc_hold_in ),
.dout ( user_cmpselinc_hold ),
assign user_cmpselinc_hold_in=user_cmpselinc_hold;
spc_mb2_ctlmsff_ctl_macro__width_3 user_cmpsel_reg (
.scan_in(user_cmpsel_reg_scanin),
.scan_out(user_cmpsel_reg_scanout),
.din ( user_cmpsel_in[2:0] ),
.dout ( user_cmpsel[2:0] ),
assign user_cmpsel_in[2:0]=user_cmpsel[2:0];
spc_mb2_ctlmsff_ctl_macro__width_1 user_loop_mode_reg (
.scan_in(user_loop_mode_reg_scanin),
.scan_out(user_loop_mode_reg_scanout),
.din ( user_loop_mode_in ),
.dout ( user_loop_mode ),
assign user_loop_mode_in=user_loop_mode;
// 10N Algorithm for bit mapping
spc_mb2_ctlmsff_ctl_macro__width_1 ten_n_mode_reg (
.scan_in(ten_n_mode_reg_scanin),
.scan_out(ten_n_mode_reg_scanout),
assign ten_n_mode_in=ten_n_mode;
spc_mb2_ctlmsff_ctl_macro__width_1 user_bisi_wr_mode_reg (
.scan_in(user_bisi_wr_mode_reg_scanin),
.scan_out(user_bisi_wr_mode_reg_scanout),
.din ( user_bisi_wr_mode_in ),
.dout ( user_bisi_wr_mode ),
assign user_bisi_wr_mode_in=user_bisi_wr_mode;
spc_mb2_ctlmsff_ctl_macro__width_1 user_bisi_rd_mode_reg (
.scan_in(user_bisi_rd_mode_reg_scanin),
.scan_out(user_bisi_rd_mode_reg_scanout),
.din ( user_bisi_rd_mode_in ),
.dout ( user_bisi_rd_mode ),
assign user_bisi_rd_mode_in=user_bisi_rd_mode;
assign mb_user_data_mode = user_mode & user_data_mode;
assign mb_user_addr_mode = user_mode & user_addr_mode;
assign mb_ten_n_mode = user_mode & ten_n_mode;
assign mb_user_loop_mode = user_mode & user_loop_mode;
assign mb_user_cmpselinc_hold = user_mode & user_cmpselinc_hold;
assign mb_user_bisi_wr_mode = user_mode & user_bisi_wr_mode & bisi_mode;
assign mb_user_bisi_rd_mode = user_mode & user_bisi_rd_mode & bisi_mode;
assign mb_user_bisi_rw_mode = ((~user_bisi_wr_mode & ~user_bisi_rd_mode) | (user_bisi_wr_mode & user_bisi_rd_mode)) & bisi_mode;
assign mb_default_bisi = bisi_mode & ~user_mode;
assign stop_addr[9:0] = ({10{ mb_user_addr_mode }} & user_stop_addr[9:0]) |
({10{~mb_user_addr_mode & array_0}} & 10'b00_0001_1111 ) | // arf
({10{~mb_user_addr_mode & array_1}} & 10'b00_0011_1111 ) | // rrf
({10{~mb_user_addr_mode & array_2}} & 10'b00_1001_1111 ) | // mam
({10{~mb_user_addr_mode & array_3}} & 10'b00_0111_1111 ) | // irf active
({10{~mb_user_addr_mode & array_4}} & 10'b00_0111_1111 ) | // irf shadow
({10{~mb_user_addr_mode & array_5}} & 10'b00_1111_1111 ); // frf
assign rw_0 = (rw[2:0]==3'b000);
assign rw_1 = (rw[2:0]==3'b001);
assign rw_2 = (rw[2:0]==3'b010);
assign rw_3 = (rw[2:0]==3'b011);
assign rw_4 = (rw[2:0]==3'b100);
assign rw_5 = (rw[2:0]==3'b101);
assign rw_6 = (rw[2:0]==3'b110);
// assign rw_7 = (rw[2:0]==3'b111);
assign march_0 = (march_element[3:0]==4'h0);
assign march_1 = (march_element[3:0]==4'h1);
assign march_2 = (march_element[3:0]==4'h2);
assign march_3 = (march_element[3:0]==4'h3);
assign march_4 = (march_element[3:0]==4'h4);
assign march_5 = (march_element[3:0]==4'h5);
assign march_6 = (march_element[3:0]==4'h6);
assign march_7 = (march_element[3:0]==4'h7);
assign march_8 = (march_element[3:0]==4'h8);
////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// address mix : fast_row and fast_column
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// arf: no column decorder or multiple bansk
// maps one to one - logical to physical
// rrf: no column decoder or banks addr[5:0]
// - address 7:5 is for block select (0-5) blocks
// - addr[0] is for column select
assign mem_addr[9:0] = (addr_mix & array_0) ? { up_addr[9:5],up_addr[3:0],up_addr[4] } : // arf fixed w/circuit
(addr_mix & array_1) ? { up_addr[9:6],up_addr[2:0],up_addr[5:3] } : // rrf fixed w/circuit
(addr_mix & array_2) ? { up_addr[9:5],up_addr[3:0],up_addr[4] } : // mam fixed w/circuit
(addr_mix & array_3) ? { up_addr[9:7],up_addr[5:0],up_addr[6] } : // irf active w/circuit
(addr_mix & array_4) ? { up_addr[9:0] } : // no addr mix for irf shadow
(addr_mix & array_5) ? { up_addr[9:8],up_addr[6:0],up_addr[7]} : // frf w/circuit
assign cntl_msb = start_in & cntl_out[34]; // done selection
assign cntl_bisi = mb_default_bisi | mb_user_bisi_rw_mode ? cntl_out[33] :
assign cntl_array_sel[3:0] = (last_array | user_mode) ? 4'b1111:
cntl_out[32:29]; // array selection
assign cntl_cmp_sel[2:0] = sel_cmp_pass ? {3'b111} :
assign sel_cmp_pass= mb_user_cmpselinc_hold |
(array_0 & cmp_0) | // arf
(array_1 & cmp_0) | // rrf
(array_2 & cmp_0) | // mam
(array_3 & cmp_0) | // irf active
(array_4 & cmp_7) | // irf shadow
(array_5 & cmp_0) ; // frf
assign cmp_sel_cntl_out[2:0] = cntl_out[28:26];
spc_mb2_ctlmsff_ctl_macro__width_3 cmp_sel_reg (
.scan_in(cmp_sel_reg_scanin),
.scan_out(cmp_sel_reg_scanout),
.dout ( cmp_sel_out[2:0] ),
assign cmp_sel[2:0]=(&cmp_sel_cntl_out[2:0] & ~array_4) ? cmp_sel_out[2:0] :
mb_user_cmpselinc_hold ? user_cmpsel[2:0] :
assign cmp_0 = cmp_sel[2:0]==3'b000;
assign cmp_7 = cmp_sel[2:0]==3'b111;
assign cntl_data_sel[1:0] = bisi_mode |
mb_user_data_mode ? 2'b11 : cntl_out[25:24]; // data selection
assign cntl_addr_mix = (bisi_mode | mb_user_addr_mode) ? 1'b1 : cntl_out[23]; // address mix
assign addr_mix = (bisi_mode | mb_user_addr_mode) ? 1'b0 : cntl_out[23];
assign cntl_march_element[3:0] = sel_march_1_pass ? 4'b1111:
cntl_out[22:19]; // march element
assign cntl_algr[15:0] = {cntl_msb,
cntl_march_element[3:0]};
assign next_algr[15:0] = cout_addr ? cntl_algr[15:0] + 16'h1 : cntl_algr[15:0]; // mbist control
assign cntl_in[34:19] = reset_engine ? {16'b000000_0000000000}:
// reset_engine run3 overflow cout_rw output
// ---------------------------------------------------------
assign sel_nextaddr_reset = reset_engine;
assign sel_nextaddr_restart = ~reset_engine & run3 & overflow;
assign sel_nextaddr_incred = ~reset_engine & run3 & ~overflow & cout_rw;
assign sel_nextaddr_same = ~(sel_nextaddr_reset | sel_nextaddr_restart | sel_nextaddr_incred);
assign cntl_in[12:3] = ({10{sel_nextaddr_reset}} & start_addr[9:0]) |
({10{sel_nextaddr_restart}} & restart_addr[9:0]) |
({10{sel_nextaddr_incred}} & incred_addr[9:0]) |
({10{sel_nextaddr_same}} & cntl_addr[9:0]);
assign incr_addr[9:0] = mb_user_addr_mode ? user_incr_addr[9:0] : 10'b00_00000001;
assign start_addr[9:0] = mb_user_addr_mode ? user_start_addr[9:0] : 10'b00_00000000;
// assign next_addr_out[9:0] = cout_rw ? cntl_addr[9:0] + incr_addr[9:0] : cntl_addr[9:0]; // next address
assign incred_addr[9:0] = cntl_addr[9:0] + incr_addr[9:0];
assign overflow = upaddr ? ( cntl_addr[9:0] == stop_addr[9:0]) & (cntl_rw[2:0]==3'b111):
(~cntl_addr[9:0] == start_addr[9:0]) & (cntl_rw[2:0]==3'b111);
// assign next_addr[9:0]= overflow ? restart_addr[9:0] : next_addr_out[9:0];
assign restart_addr[9:0] = upaddr_pre ? start_addr[9:0] : ~stop_addr[9:0];
assign cout_addr = overflow;
assign march_element_pre[3:0]=next_algr[3:0];
assign march_pre_0 = ~(march_element_pre[3] | march_element_pre[2] | march_element_pre[1] | march_element_pre[0]);
assign march_pre_1 = ~(march_element_pre[3] | march_element_pre[2] | march_element_pre[1] | ~march_element_pre[0]);
assign march_pre_2 = ~(march_element_pre[3] | march_element_pre[2] | ~march_element_pre[1] | march_element_pre[0]);
assign march_pre_6 = ~(march_element_pre[3] |~march_element_pre[2] | ~march_element_pre[1] | march_element_pre[0]);
assign march_pre_7 = ~(march_element_pre[3] | march_element_pre[3] | ~march_element_pre[2] | ~march_element_pre[1] | ~march_element_pre[0]);
assign upaddr_pre = march_pre_0 | march_pre_1 | march_pre_2 | march_pre_6 | march_pre_7;
/////////////////////////
/////////////////////////
assign cntl_rw[2:0] = sel_rw_pass ? 3'b111:
cntl_out[ 2: 0]; // read write control
assign next_rw[2:0] = cntl_rw[2:0]+3'b001 ;
assign cout_rw = &cntl_rw[2:0]; // carry over for rw
assign cntl_in[2:0] = reset_engine ? 3'b000 :
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
assign array_0 = array_sel[3:0]==4'h0;
assign array_1 = array_sel[3:0]==4'h1;
assign array_2 = array_sel[3:0]==4'h2;
assign array_3 = array_sel[3:0]==4'h3;
assign array_4 = array_sel[3:0]==4'h4;
assign array_5 = array_sel[3:0]==4'h5;
// assign array_end = array_sel[3:0]==4'h5;
assign last_array = array_5;
// /////////////////////////////////////////////////////////////////////////////
// MBIST Control Register
// /////////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////////
// ^(W0);^(R0W1);^(R1W0);v(R0W1);v(R1W0);v(R0);^(W1W0*R1R0W0);v(W1);^(W0W1*R0R1W1);
// - there are 9 march elements in the engine
// march_0 - march_8 indicate which march element it's in
// - for each march element, there are write and read sequences and for some
// just write or just read
// - for each march element, it can move upaddr (0-max) or downaddr (max-0)
// march rw upaddr truedata
// --------------------------------------------------------------------------------
// - march_0 w 1 one_cycle_march rw_0 ^(W0)
// - march_1 rw 1 two_cycle_march rw_0 ^(R0W1)
// - march_2 rw 1 two_cycle_march rw_1 ^(R1W0)
// - march_3 rw 0 two_cycle_march rw_0 v(R0W1)
// - march_4 rw 0 two_cycle_march rw_1 v(R1W0)
// - march_5 r 0 one_cycle_march rw_0 v(R0)
// - march_6 wwrrw 1 five_cycle_march rw_1,3,4 ^(W1W0*R1R0W0)
// - march_7 w 0 one_cycle_march -- v(W1)
// - march_8 wwrrw 1 five_cycle_march rw_0,2 ^(W0W1*R0R1W1)
// one_cycle_march : march_0 | march_5 | march_7
// five_cycle_march : march_6 | march_8
// two_cycle_march : ~(one_cycle_march | five_cycle_march)
////////////////////////////////////////////////////////////////////////////////
// the different between cntl_march and march is that march is before mux and
// and cntl_march is after mux
// write: W1,S1,X,W0,restore
// rw : R1,W1,S1,X,W0,restore
spc_mb2_ctlmsff_ctl_macro__width_29 cntl_reg (
.scan_in(cntl_reg_scanin),
.scan_out(cntl_reg_scanout),
.din ({cntl_in[34:19] ,cntl_in[12:0]} ),
.dout ({cntl_out[34:19],cntl_out[12:0]} ),
assign one_cycle_march = march_0 | march_5 | march_7;
assign five_cycle_march = march_6 | march_8;
assign two_cycle_march = ~(one_cycle_march | five_cycle_march);
// this will indicate last march turn
assign sel_march_1_pass = bisi_mode | ((mb_ten_n_mode | array_4) & march_5) | march_8;
assign bisi_wr_mode = mb_default_bisi | mb_user_bisi_rw_mode ? ~cntl_bisi & run3 :
mb_user_bisi_wr_mode & run3;
assign bisi_rd_mode =mb_default_bisi | mb_user_bisi_rw_mode ? cntl_bisi & run3 :
mb_user_bisi_rd_mode & run3;
assign sel_rw_1_pass = bisi_mode | one_cycle_march ;
assign sel_rw_2_pass = two_cycle_march;
assign sel_rw_5_pass = five_cycle_march;
assign sel_rw_pass = (run3 & sel_rw_1_pass & rw_0 & ~array_4) |
(run3 & sel_rw_2_pass & rw_1 & ~array_4) |
(run3 & sel_rw_5_pass & rw_4 & ~array_4) |
(run3 & array_4 & march_5 & rw_0) |
(run3 & array_4 & march_0 & rw_5) |
(run3 & array_4 & ~(march_5 | march_0) & rw_6) ;
assign true_data_l = bisi_mode |
(array_4 & march_0 & ~rw_3) |
(~array_4 & march_1 & rw_0) |
(array_4 & march_1 & (rw_0 | rw_4)) |
(~array_4 & march_2 & rw_1) |
(array_4 & march_2 & (rw_1 | rw_4)) |
(~array_4 & march_3 & rw_0) |
(array_4 & march_3 & (rw_0 | rw_4)) |
(~array_4 & march_4 & rw_1) |
(array_4 & march_4 & (rw_1 | rw_4)) |
(march_6 & (rw_1 | rw_3 | rw_4)) |
(march_8 & (rw_0 | rw_2));
assign true_data=~true_data_l;
assign data_pat_sel[7:0] = mb_user_data_mode ? user_data[7:0]:
(cntl_data_sel[1:0] == 2'h0) ? 8'hAA:
(cntl_data_sel[1:0] == 2'h1) ? 8'h99:
(cntl_data_sel[1:0] == 2'h2) ? 8'hCC:
assign mem_data1[7:0] = (true_data) ? data_pat_sel[7:0] : ~data_pat_sel[7:0];
assign mem_data[7:0] = ~array_4 ? mem_data1[7:0] :
array_4 & bisi_mode ? 8'h00 :
assign cntl_addr[9:0] = cntl_out[12:3];
assign adj_addr = (five_cycle_march & (rw_1 | rw_3)) ? {cntl_addr[9:3],~cntl_addr[2],cntl_addr[1:0]}:
assign up_addr[9:0] = upaddr ? adj_addr[9:0]: ~adj_addr[9:0];
/////////////////////////
/////////////////////////
assign mem_wr_pbi = (run3 & ~array_4 & (
((march_1 | march_2 | march_3 | march_4 ) & rw_1) |
(march_6 & (rw_0 | rw_1 | rw_4)) |
(march_8 & (rw_0 | rw_1 | rw_4))
(march_0 & (rw_0 | rw_3)) |
((march_1 | march_2 | march_3 | march_4 ) & (rw_1 | rw_4))
assign mem_wr = bisi_wr_mode ? mem_wr_pbi :
assign mem_save = (run3 & array_4 & ((march_0 & rw_1) | (~march_0 & rw_2)));
assign mem_restore = (run3 & array_4 & ((march_0 & rw_4) | (~march_0 & rw_5)));
/////////////////////////
/////////////////////////
assign mem_rd_pbi = (~array_4 & run3 & ~mem_wr) |
( array_4 & run3 & ~march_0 & rw_0);
assign mem_rd= bisi_rd_mode ? 1'b1 : mem_rd_pbi;
assign upaddr = march_0 | march_1 | march_2 | march_6 | march_7 | bisi_mode ;
assign array_sel_cntl_out[3:0]=cntl_out[32:29];
spc_mb2_ctlmsff_ctl_macro__width_4 array_sel_reg (
.scan_in(array_sel_reg_scanin),
.scan_out(array_sel_reg_scanout),
.dout ( array_sel_out[3:0] ),
assign array_sel[3:0]=(&array_sel_cntl_out[3:0]) ? array_sel_out[3:0] :
user_mode ? user_array[3:0] :
assign march_element_cntl_out[3:0]=cntl_out[22:19];
spc_mb2_ctlmsff_ctl_macro__width_4 marche_element_reg (
.scan_in(marche_element_reg_scanin),
.scan_out(marche_element_reg_scanout),
.din ( march_element[3:0] ),
.dout ( march_element_out ),
assign march_element[3:0]=(&march_element_cntl_out[3:0]) ? march_element_out[3:0] :
march_element_cntl_out[3:0];
assign rw[2:0]=cntl_out[2:0];
//////////////////////////////////// ////////////////////////////////////
//////////////////////////////////// ////////////////////////////////////
// assign mbist_cmp_sel[2:0]=~cntl_cmp_sel[2:0];
assign mb_addr[15:0]=array_4 ? {6'b000000,cmp_sel[2:0],mem_addr[6:0]} : {6'b000000,mem_addr[9:0]};
assign mb_write_data[7:0]=mem_data[7:0];
// only one array read signal should be active
assign mb_array_0_rd= array_0 & mem_rd;
assign mb_array_1_rd= array_1 & mem_rd;
assign mb_array_2_rd= array_2 & mem_rd;
assign mb_array_3_rd= (array_3 & mem_rd & ((|mem_addr[4:0]) | ~(|mem_data[7:0])) & ~bisi_mode) |
(array_4 & mem_rd & ((|mem_addr[4:0]) | ~(|mem_data[7:0])) & ~bisi_mode);
assign mb_array_save= mem_save;
assign mb_array_5_rd= array_5 & mem_rd;
// only one array write signal should be active
assign mb_array_0_wr= array_0 & mem_wr;
assign mb_array_1_wr= array_1 & mem_wr;
assign mb_array_2_wr= array_2 & mem_wr;
assign mb_array_3_wr= (array_3 & mem_wr) | (array_4 & mem_wr);
assign mb_array_restore = mem_restore;
assign mb_array_5_wr= array_5 & mem_wr;
// fail sigals from arrays
assign spu_arf_fail = mb2_arf_read_en_p2 & ~spu_mbi_arf_fail_;
assign spu_rrf_fail = mb2_rrf_read_en_p2 & ~spu_mbi_rrf_fail_;
assign spu_mam_fail = (mb2_mam_read_en_p2 & ~spu_mbi_mam_fail_ ) |
(mb2_mam_read_en_p2 & ~spu_mbi_mam_fail2_);
assign exu0_irf_fail = (mb2_irf_read_en_p4 & ~exu0_mbi_irf_fail_[0] ) |
(mb2_irf_read_en_p4 & ~exu0_mbi_irf_fail_[1]);
assign exu1_irf_fail = (mb2_irf_read_en_p4 & ~exu1_mbi_irf_fail_[0] ) |
(mb2_irf_read_en_p4 & ~exu1_mbi_irf_fail_[1]);
assign arf_fail = run3_transition ? 1'b0 : (spu_arf_fail | spu_arf_fail_sticky);
assign rrf_fail = run3_transition ? 1'b0 : (spu_rrf_fail | spu_rrf_fail_sticky);
assign mam_fail = run3_transition ? 1'b0 : (spu_mam_fail | spu_mam_fail_sticky);
assign irf0_fail = run3_transition ? 1'b0 : (exu0_irf_fail | exu0_irf_fail_sticky);
assign irf1_fail = run3_transition ? 1'b0 : (exu1_irf_fail | exu1_irf_fail_sticky);
assign frf_fail = run3_transition ? 1'b0 : (fgu_mbi_frf_fail | fgu_frf_fail_sticky);
spc_mb2_ctlmsff_ctl_macro__width_6 fail_reg (
.scan_in(fail_reg_scanin),
.scan_out(fail_reg_scanout),
.dout ({spu_arf_fail_sticky ,
assign mbist_fail_sticky = spu_arf_fail_sticky |
assign mbist_fail_array = spu_arf_fail |
assign valid_fail=run3 | (stop_engine_l & ~mb_done);
assign mb_fail = mb_done ? mbist_fail_sticky : mbist_fail_array & valid_fail;
//////////////////////////////////// ////////////////////////////////////
//////////////////////////////////// ////////////////////////////////////
spc_mb2_ctlmsff_ctl_macro__width_1 msb_latch (
.scan_in(msb_latch_scanin),
.scan_out(msb_latch_scanout),
assign msb_in= (~start_in ) | (mb_user_loop_mode & mb_done) ? 1'b0 :
assign stop_engine_l = start_in & cntl_msb;
assign mb_done=msb_out & (done_delay[4:0]==5'b11110);
assign run3 = &done_delay[4:1] & ~stop_engine_l & start_in;
spc_mb2_ctlmsff_ctl_macro__width_1 run3_transition_reg (
.scan_in(run3_transition_reg_scanin),
.scan_out(run3_transition_reg_scanout),
assign run3_transition = run3 & ~run3_out;
spc_mb2_ctlmsff_ctl_macro__width_5 done_delay_reg (
.scan_in(done_delay_reg_scanin),
.scan_out(done_delay_reg_scanout),
.din ( done_delay_in[4:0] ),
.dout ( done_delay[4:0] ),
assign done_delay_in[4:0] = run3 ? 5'b11111 :
(run & ~run3) ? done_delay[4:0] + 5'b00001 :
//////////////////////////////////// ////////////////////////////////////
//////////////////////////////////// ////////////////////////////////////
spc_mb2_ctlmsff_ctl_macro__width_1 out_run_mb_arrays_reg (
.scan_in(out_run_mb_arrays_reg_scanin),
.scan_out(out_run_mb_arrays_reg_scanout),
spc_mb2_ctlmsff_ctl_macro__width_8 out_data_mb_arrays_reg (
.scan_in(out_data_mb_arrays_reg_scanin),
.scan_out(out_data_mb_arrays_reg_scanout),
.din ( mb_write_data[7:0] ),
.dout ( mb_write_data_out[7:0] ),
spc_mb2_ctlmsff_ctl_macro__width_16 out_addr_mb_arrays_reg (
.scan_in(out_addr_mb_arrays_reg_scanin),
.scan_out(out_addr_mb_arrays_reg_scanout),
.dout ( mb_addr_out[15:0] ),
spc_mb2_ctlmsff_ctl_macro__width_5 out_wr_mb_arrays_reg (
.scan_in(out_wr_mb_arrays_reg_scanin),
.scan_out(out_wr_mb_arrays_reg_scanout),
spc_mb2_ctlmsff_ctl_macro__width_5 out_rd_mb_arrays_reg (
.scan_in(out_rd_mb_arrays_reg_scanin),
.scan_out(out_rd_mb_arrays_reg_scanout),
assign mb2_run=mb_run_out;
assign mb2_write_data[7:0]=mb_write_data_out[7:0];
assign mb2_addr[15:0]=mb_addr_out[15:0];
assign mb2_arf_write_en=mb_array_0_wr_out;
assign mb2_rrf_write_en=mb_array_1_wr_out;
assign mb2_mam_write_en=mb_array_2_wr_out;
assign mb2_irf_write_en=mb_array_3_wr_out;
assign mb2_frf_write_en=mb_array_5_wr_out;
assign mb2_arf_read_en=mb_array_0_rd_out;
assign mb2_rrf_read_en=mb_array_1_rd_out;
assign mb2_mam_read_en=mb_array_2_rd_out;
assign mb2_irf_read_en=mb_array_3_rd_out;
assign mb2_frf_read_en=mb_array_5_rd_out;
spc_mb2_ctlmsff_ctl_macro__width_1 out_mb_tcu_done_reg (
.scan_in(out_mb_tcu_done_reg_scanin),
.scan_out(out_mb_tcu_done_reg_scanout),
spc_mb2_ctlmsff_ctl_macro__width_1 out_mb_tcu_fail_reg (
.scan_in(out_mb_tcu_fail_reg_scanin),
.scan_out(out_mb_tcu_fail_reg_scanout),
assign mb2_done=mb_done_out;
assign mb2_mbist_fail=mb_fail_out;
spc_mb2_ctlspare_ctl_macro__num_3 spares (
.scan_out(spares_scanout),
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// assign first_six_march =~(march_6 | march_7 | march_8);
spc_mb2_ctlmsff_ctl_macro__width_4 i_delay_4th (
.scan_in(i_delay_4th_scanin),
.scan_out(i_delay_4th_scanout),
.dout ({mb2_irf_read_en_p1 ,
// delayed compare read and data signals
spc_mb2_ctlmsff_ctl_macro__width_22 delayed_cmp_rd_data_reg (
.scan_in(delayed_cmp_rd_data_reg_scanin),
.scan_out(delayed_cmp_rd_data_reg_scanout),
mb2_write_data_p1[7:0]} ),
.dout ({mb2_arf_read_en_p1 ,
mb2_write_data_p2[7:0]} ),
// save and restore signals to arrays
spc_mb2_ctlmsff_ctl_macro__width_2 out_save_restore_mb_arrays_reg (
.scan_in(out_save_restore_mb_arrays_reg_scanin),
.scan_out(out_save_restore_mb_arrays_reg_scanout),
.dout ({mb2_irf_save_en ,
assign pmen_scanin = scan_in ;
assign input_signals_reg_scanin = pmen_scanout ;
assign mb_enable_reg_scanin = input_signals_reg_scanout;
assign config_reg_scanin = mb_enable_reg_scanout ;
assign loop_again_reg_scanin = config_reg_scanout ;
assign array_usr_reg_scanin = loop_again_reg_scanout ;
assign user_addr_mode_reg_scanin = array_usr_reg_scanout ;
assign user_start_addr_reg_scanin = user_addr_mode_reg_scanout;
assign user_stop_addr_reg_scanin = user_start_addr_reg_scanout;
assign user_incr_addr_reg_scanin = user_stop_addr_reg_scanout;
assign user_data_mode_reg_scanin = user_incr_addr_reg_scanout;
assign user_data_reg_scanin = user_data_mode_reg_scanout;
assign user_cmpselinc_hold_reg_scanin = user_data_reg_scanout ;
assign user_cmpsel_reg_scanin = user_cmpselinc_hold_reg_scanout;
assign user_loop_mode_reg_scanin = user_cmpsel_reg_scanout ;
assign ten_n_mode_reg_scanin = user_loop_mode_reg_scanout;
assign user_bisi_wr_mode_reg_scanin = ten_n_mode_reg_scanout ;
assign user_bisi_rd_mode_reg_scanin = user_bisi_wr_mode_reg_scanout;
assign cmp_sel_reg_scanin = user_bisi_rd_mode_reg_scanout;
assign cntl_reg_scanin = cmp_sel_reg_scanout ;
assign array_sel_reg_scanin = cntl_reg_scanout ;
assign marche_element_reg_scanin = array_sel_reg_scanout ;
assign fail_reg_scanin = marche_element_reg_scanout;
assign msb_latch_scanin = fail_reg_scanout ;
assign run3_transition_reg_scanin = msb_latch_scanout ;
assign done_delay_reg_scanin = run3_transition_reg_scanout;
assign out_run_mb_arrays_reg_scanin = done_delay_reg_scanout ;
assign out_data_mb_arrays_reg_scanin = out_run_mb_arrays_reg_scanout;
assign out_addr_mb_arrays_reg_scanin = out_data_mb_arrays_reg_scanout;
assign out_wr_mb_arrays_reg_scanin = out_addr_mb_arrays_reg_scanout;
assign out_rd_mb_arrays_reg_scanin = out_wr_mb_arrays_reg_scanout;
assign out_mb_tcu_done_reg_scanin = out_rd_mb_arrays_reg_scanout;
assign out_mb_tcu_fail_reg_scanin = out_mb_tcu_done_reg_scanout;
assign spares_scanin = out_mb_tcu_fail_reg_scanout;
assign i_delay_4th_scanin = spares_scanout ;
assign delayed_cmp_rd_data_reg_scanin = i_delay_4th_scanout ;
assign out_save_restore_mb_arrays_reg_scanin = delayed_cmp_rd_data_reg_scanout;
assign scan_out = out_save_restore_mb_arrays_reg_scanout;
// any PARAMS parms go into naming of macro
module spc_mb2_ctll1clkhdr_ctl_macro (
// any PARAMS parms go into naming of macro
module spc_mb2_ctlmsff_ctl_macro__width_3 (
assign fdin[2:0] = din[2:0];
// any PARAMS parms go into naming of macro
module spc_mb2_ctlmsff_ctl_macro__width_2 (
assign fdin[1:0] = din[1:0];
// any PARAMS parms go into naming of macro
module spc_mb2_ctlmsff_ctl_macro__width_1 (
assign fdin[0:0] = din[0:0];
// any PARAMS parms go into naming of macro
module spc_mb2_ctlmsff_ctl_macro__width_4 (
assign fdin[3:0] = din[3:0];
// any PARAMS parms go into naming of macro
module spc_mb2_ctlmsff_ctl_macro__width_10 (
assign fdin[9:0] = din[9:0];
// any PARAMS parms go into naming of macro
module spc_mb2_ctlmsff_ctl_macro__width_8 (
assign fdin[7:0] = din[7:0];
// any PARAMS parms go into naming of macro
module spc_mb2_ctlmsff_ctl_macro__width_29 (
assign fdin[28:0] = din[28:0];
.so({so[27:0],scan_out}),
// any PARAMS parms go into naming of macro
module spc_mb2_ctlmsff_ctl_macro__width_6 (
assign fdin[5:0] = din[5:0];
// any PARAMS parms go into naming of macro
module spc_mb2_ctlmsff_ctl_macro__width_5 (
assign fdin[4:0] = din[4:0];
// any PARAMS parms go into naming of macro
module spc_mb2_ctlmsff_ctl_macro__width_16 (
assign fdin[15:0] = din[15:0];
.so({so[14:0],scan_out}),
// Description: Spare gate macro for control blocks
// Param num controls the number of times the macro is added
// flops=0 can be used to use only combination spare logic
module spc_mb2_ctlspare_ctl_macro__num_3 (
wire spare0_buf_32x_unused;
wire spare0_nand3_8x_unused;
wire spare0_inv_8x_unused;
wire spare0_aoi22_4x_unused;
wire spare0_buf_8x_unused;
wire spare0_oai22_4x_unused;
wire spare0_inv_16x_unused;
wire spare0_nand2_16x_unused;
wire spare0_nor3_4x_unused;
wire spare0_nand2_8x_unused;
wire spare0_buf_16x_unused;
wire spare0_nor2_16x_unused;
wire spare0_inv_32x_unused;
wire spare1_buf_32x_unused;
wire spare1_nand3_8x_unused;
wire spare1_inv_8x_unused;
wire spare1_aoi22_4x_unused;
wire spare1_buf_8x_unused;
wire spare1_oai22_4x_unused;
wire spare1_inv_16x_unused;
wire spare1_nand2_16x_unused;
wire spare1_nor3_4x_unused;
wire spare1_nand2_8x_unused;
wire spare1_buf_16x_unused;
wire spare1_nor2_16x_unused;
wire spare1_inv_32x_unused;
wire spare2_buf_32x_unused;
wire spare2_nand3_8x_unused;
wire spare2_inv_8x_unused;
wire spare2_aoi22_4x_unused;
wire spare2_buf_8x_unused;
wire spare2_oai22_4x_unused;
wire spare2_inv_16x_unused;
wire spare2_nand2_16x_unused;
wire spare2_nor3_4x_unused;
wire spare2_nand2_8x_unused;
wire spare2_buf_16x_unused;
wire spare2_nor2_16x_unused;
wire spare2_inv_32x_unused;
cl_sc1_msff_8x spare0_flop (.l1clk(l1clk),
cl_u1_buf_32x spare0_buf_32x (.in(1'b1),
.out(spare0_buf_32x_unused));
cl_u1_nand3_8x spare0_nand3_8x (.in0(1'b1),
.out(spare0_nand3_8x_unused));
cl_u1_inv_8x spare0_inv_8x (.in(1'b1),
.out(spare0_inv_8x_unused));
cl_u1_aoi22_4x spare0_aoi22_4x (.in00(1'b1),
.out(spare0_aoi22_4x_unused));
cl_u1_buf_8x spare0_buf_8x (.in(1'b1),
.out(spare0_buf_8x_unused));
cl_u1_oai22_4x spare0_oai22_4x (.in00(1'b1),
.out(spare0_oai22_4x_unused));
cl_u1_inv_16x spare0_inv_16x (.in(1'b1),
.out(spare0_inv_16x_unused));
cl_u1_nand2_16x spare0_nand2_16x (.in0(1'b1),
.out(spare0_nand2_16x_unused));
cl_u1_nor3_4x spare0_nor3_4x (.in0(1'b0),
.out(spare0_nor3_4x_unused));
cl_u1_nand2_8x spare0_nand2_8x (.in0(1'b1),
.out(spare0_nand2_8x_unused));
cl_u1_buf_16x spare0_buf_16x (.in(1'b1),
.out(spare0_buf_16x_unused));
cl_u1_nor2_16x spare0_nor2_16x (.in0(1'b0),
.out(spare0_nor2_16x_unused));
cl_u1_inv_32x spare0_inv_32x (.in(1'b1),
.out(spare0_inv_32x_unused));
cl_sc1_msff_8x spare1_flop (.l1clk(l1clk),
cl_u1_buf_32x spare1_buf_32x (.in(1'b1),
.out(spare1_buf_32x_unused));
cl_u1_nand3_8x spare1_nand3_8x (.in0(1'b1),
.out(spare1_nand3_8x_unused));
cl_u1_inv_8x spare1_inv_8x (.in(1'b1),
.out(spare1_inv_8x_unused));
cl_u1_aoi22_4x spare1_aoi22_4x (.in00(1'b1),
.out(spare1_aoi22_4x_unused));
cl_u1_buf_8x spare1_buf_8x (.in(1'b1),
.out(spare1_buf_8x_unused));
cl_u1_oai22_4x spare1_oai22_4x (.in00(1'b1),
.out(spare1_oai22_4x_unused));
cl_u1_inv_16x spare1_inv_16x (.in(1'b1),
.out(spare1_inv_16x_unused));
cl_u1_nand2_16x spare1_nand2_16x (.in0(1'b1),
.out(spare1_nand2_16x_unused));
cl_u1_nor3_4x spare1_nor3_4x (.in0(1'b0),
.out(spare1_nor3_4x_unused));
cl_u1_nand2_8x spare1_nand2_8x (.in0(1'b1),
.out(spare1_nand2_8x_unused));
cl_u1_buf_16x spare1_buf_16x (.in(1'b1),
.out(spare1_buf_16x_unused));
cl_u1_nor2_16x spare1_nor2_16x (.in0(1'b0),
.out(spare1_nor2_16x_unused));
cl_u1_inv_32x spare1_inv_32x (.in(1'b1),
.out(spare1_inv_32x_unused));
cl_sc1_msff_8x spare2_flop (.l1clk(l1clk),
cl_u1_buf_32x spare2_buf_32x (.in(1'b1),
.out(spare2_buf_32x_unused));
cl_u1_nand3_8x spare2_nand3_8x (.in0(1'b1),
.out(spare2_nand3_8x_unused));
cl_u1_inv_8x spare2_inv_8x (.in(1'b1),
.out(spare2_inv_8x_unused));
cl_u1_aoi22_4x spare2_aoi22_4x (.in00(1'b1),
.out(spare2_aoi22_4x_unused));
cl_u1_buf_8x spare2_buf_8x (.in(1'b1),
.out(spare2_buf_8x_unused));
cl_u1_oai22_4x spare2_oai22_4x (.in00(1'b1),
.out(spare2_oai22_4x_unused));
cl_u1_inv_16x spare2_inv_16x (.in(1'b1),
.out(spare2_inv_16x_unused));
cl_u1_nand2_16x spare2_nand2_16x (.in0(1'b1),
.out(spare2_nand2_16x_unused));
cl_u1_nor3_4x spare2_nor3_4x (.in0(1'b0),
.out(spare2_nor3_4x_unused));
cl_u1_nand2_8x spare2_nand2_8x (.in0(1'b1),
.out(spare2_nand2_8x_unused));
cl_u1_buf_16x spare2_buf_16x (.in(1'b1),
.out(spare2_buf_16x_unused));
cl_u1_nor2_16x spare2_nor2_16x (.in0(1'b0),
.out(spare2_nor2_16x_unused));
cl_u1_inv_32x spare2_inv_32x (.in(1'b1),
.out(spare2_inv_32x_unused));
// any PARAMS parms go into naming of macro
module spc_mb2_ctlmsff_ctl_macro__width_22 (
assign fdin[21:0] = din[21:0];
.so({so[20:0],scan_out}),