projects / OpenSPARC-T2-DV / blame
| Commit | Line | Data |
|---|---|---|
| 86530b38 AT |
1 | // ========== Copyright Header Begin ========================================== |
| 2 | // | |
| 3 | // OpenSPARC T2 Processor File: n2_com_cm_32x40_cust.v | |
| 4 | // Copyright (C) 1995-2007 Sun Microsystems, Inc. All Rights Reserved | |
| 5 | // 4150 Network Circle, Santa Clara, California 95054, U.S.A. | |
| 6 | // | |
| 7 | // * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| 8 | // | |
| 9 | // This program is free software; you can redistribute it and/or modify | |
| 10 | // it under the terms of the GNU General Public License as published by | |
| 11 | // the Free Software Foundation; version 2 of the License. | |
| 12 | // | |
| 13 | // This program is distributed in the hope that it will be useful, | |
| 14 | // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 15 | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 16 | // GNU General Public License for more details. | |
| 17 | // | |
| 18 | // You should have received a copy of the GNU General Public License | |
| 19 | // along with this program; if not, write to the Free Software | |
| 20 | // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| 21 | // | |
| 22 | // For the avoidance of doubt, and except that if any non-GPL license | |
| 23 | // choice is available it will apply instead, Sun elects to use only | |
| 24 | // the General Public License version 2 (GPLv2) at this time for any | |
| 25 | // software where a choice of GPL license versions is made | |
| 26 | // available with the language indicating that GPLv2 or any later version | |
| 27 | // may be used, or where a choice of which version of the GPL is applied is | |
| 28 | // otherwise unspecified. | |
| 29 | // | |
| 30 | // Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 31 | // CA 95054 USA or visit www.sun.com if you need additional information or | |
| 32 | // have any questions. | |
| 33 | // | |
| 34 | // ========== Copyright Header End ============================================ | |
| 35 | module n2_com_cm_32x40_cust ( | |
| 36 | adr_w, | |
| 37 | din, | |
| 38 | write_en, | |
| 39 | tcu_array_wr_inhibit, | |
| 40 | adr_r, | |
| 41 | read_en, | |
| 42 | lookup_en, | |
| 43 | key, | |
| 44 | l2clk, | |
| 45 | tcu_se_scancollar_in, | |
| 46 | scan_in, | |
| 47 | tcu_pce_ov, | |
| 48 | pce, | |
| 49 | tcu_aclk, | |
| 50 | tcu_bclk, | |
| 51 | tcu_scan_en, | |
| 52 | tcu_clk_stop, | |
| 53 | tcu_array_bypass, | |
| 54 | scan_out, | |
| 55 | match, | |
| 56 | match_idx, | |
| 57 | dout); | |
| 58 | wire siclk; | |
| 59 | wire soclk; | |
| 60 | wire pce_ov; | |
| 61 | wire l1clk_in; | |
| 62 | wire l1clk_en; | |
| 63 | wire [142:0] so; | |
| 64 | wire [152:0] xx_unused; | |
| 65 | wire [152:0] xx0_unused; | |
| 66 | wire [41:0] din_d1; | |
| 67 | wire [41:7] key_d1; | |
| 68 | wire lkup_so; | |
| 69 | wire lookup_en_d1; | |
| 70 | wire mb_ren_d1; | |
| 71 | wire mb_wen_d1; | |
| 72 | wire [31:0] adr_r_d1; | |
| 73 | wire [31:0] adr_w_d1; | |
| 74 | ||
| 75 | ||
| 76 | input [31:0] adr_w ; // set up to +ve edge, BS & SR 11/04/03, MB grows to 32 | |
| 77 | input [41:0] din; // set up to +ve edge | |
| 78 | input write_en; // +ve edge clk; write enable | |
| 79 | input tcu_array_wr_inhibit; // used to gate off writes during SCAN. | |
| 80 | input [31:0] adr_r; // set up to +ve edge, BS & SR 11/04/03, MB grows to 32 | |
| 81 | input read_en; | |
| 82 | input lookup_en; // set up to -ve edge | |
| 83 | input [41:7] key; // set up to -ve edge | |
| 84 | input l2clk ; | |
| 85 | input tcu_se_scancollar_in; | |
| 86 | input scan_in; | |
| 87 | input tcu_pce_ov; | |
| 88 | input pce; | |
| 89 | input tcu_aclk; | |
| 90 | input tcu_bclk; | |
| 91 | input tcu_scan_en; | |
| 92 | input tcu_clk_stop; | |
| 93 | input tcu_array_bypass; // array bypass for DFT | |
| 94 | ||
| 95 | output scan_out; | |
| 96 | output [31:0] match ; | |
| 97 | output [31:0] match_idx ; | |
| 98 | output [41:0] dout; | |
| 99 | ||
| 100 | // JDL 05/17/07 | |
| 101 | // synopsys translate_off | |
| 102 | ||
| 103 | wire [41:0] dout_array; | |
| 104 | wire [31:0] match_array; | |
| 105 | wire [31:0] match_idx_array; | |
| 106 | ||
| 107 | // scan chain connections //// | |
| 108 | wire stop; | |
| 109 | assign siclk = tcu_aclk; | |
| 110 | assign soclk = tcu_bclk; | |
| 111 | //assign se = tcu_scan_en; | |
| 112 | assign stop = tcu_clk_stop; | |
| 113 | assign pce_ov = tcu_pce_ov; | |
| 114 | ||
| 115 | assign dout = dout_array; | |
| 116 | ||
| 117 | //// Input Flops ///// | |
| 118 | ||
| 119 | ||
| 120 | /////////// | |
| 121 | n2_com_cm_32x40_cust_l1clkhdr_ctl_macro collar_in | |
| 122 | ( | |
| 123 | .l2clk (l2clk ), | |
| 124 | .l1en (pce ), | |
| 125 | .pce_ov (pce_ov ), | |
| 126 | .stop (stop ), | |
| 127 | .se (tcu_se_scancollar_in), | |
| 128 | .l1clk (l1clk_in ) | |
| 129 | ); | |
| 130 | ||
| 131 | n2_com_cm_32x40_cust_l1clkhdr_ctl_macro scan_en | |
| 132 | ( | |
| 133 | .l2clk (l2clk ), | |
| 134 | .l1en (pce ), | |
| 135 | .pce_ov (pce_ov ), | |
| 136 | .stop (stop ), | |
| 137 | .se (tcu_scan_en), | |
| 138 | .l1clk (l1clk_en ) | |
| 139 | ); | |
| 140 | ||
| 141 | ||
| 142 | ||
| 143 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx0 (.scan_in(scan_in), .scan_out(so[0]), .l1clk(l1clk_in), .d(din[0]), .latout(xx_unused[0]), .q_l(xx0_unused[0]), .q(din_d1[0]), | |
| 144 | .siclk(siclk), | |
| 145 | .soclk(soclk)); | |
| 146 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx1 (.scan_in(so[0]), .scan_out(so[1]), .l1clk(l1clk_in), .d(din[1]), .latout(xx_unused[1]), .q_l(xx0_unused[1]), .q(din_d1[1]), | |
| 147 | .siclk(siclk), | |
| 148 | .soclk(soclk)); | |
| 149 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx2 (.scan_in(so[1]), .scan_out(so[2]), .l1clk(l1clk_in), .d(din[2]), .latout(xx_unused[2]), .q_l(xx0_unused[2]), .q(din_d1[2]), | |
| 150 | .siclk(siclk), | |
| 151 | .soclk(soclk)); | |
| 152 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx3 (.scan_in(so[2]), .scan_out(so[3]), .l1clk(l1clk_in), .d(din[3]), .latout(xx_unused[3]), .q_l(xx0_unused[3]), .q(din_d1[3]), | |
| 153 | .siclk(siclk), | |
| 154 | .soclk(soclk)); | |
| 155 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx4 (.scan_in(so[3]), .scan_out(so[4]), .l1clk(l1clk_in), .d(din[4]), .latout(xx_unused[4]), .q_l(xx0_unused[4]), .q(din_d1[4]), | |
| 156 | .siclk(siclk), | |
| 157 | .soclk(soclk)); | |
| 158 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx5 (.scan_in(so[4]), .scan_out(so[5]), .l1clk(l1clk_in), .d(din[5]), .latout(xx_unused[5]), .q_l(xx0_unused[5]), .q(din_d1[5]), | |
| 159 | .siclk(siclk), | |
| 160 | .soclk(soclk)); | |
| 161 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx6 (.scan_in(so[5]), .scan_out(so[6]), .l1clk(l1clk_in), .d(din[6]), .latout(xx_unused[6]), .q_l(xx0_unused[6]), .q(din_d1[6]), | |
| 162 | .siclk(siclk), | |
| 163 | .soclk(soclk)); | |
| 164 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx7 (.scan_in(so[6]), .scan_out(so[7]), .l1clk(l1clk_in), .d(din[9]), .latout(xx_unused[7]), .q_l(xx0_unused[7]), .q(din_d1[9]), | |
| 165 | .siclk(siclk), | |
| 166 | .soclk(soclk)); | |
| 167 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx8 (.scan_in(so[7]), .scan_out(so[8]), .l1clk(l1clk_in), .d(din[10]), .latout(xx_unused[8]), .q_l(xx0_unused[8]), .q(din_d1[10]), | |
| 168 | .siclk(siclk), | |
| 169 | .soclk(soclk)); | |
| 170 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx9 (.scan_in(so[8]), .scan_out(so[9]), .l1clk(l1clk_in), .d(din[11]), .latout(xx_unused[9]), .q_l(xx0_unused[9]), .q(din_d1[11]), | |
| 171 | .siclk(siclk), | |
| 172 | .soclk(soclk)); | |
| 173 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx10 (.scan_in(so[9]), .scan_out(so[10]), .l1clk(l1clk_in), .d(din[12]), .latout(xx_unused[10]), .q_l(xx0_unused[10]), .q(din_d1[12]), | |
| 174 | .siclk(siclk), | |
| 175 | .soclk(soclk)); | |
| 176 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx11 (.scan_in(so[10]), .scan_out(so[11]), .l1clk(l1clk_in), .d(din[13]), .latout(xx_unused[11]), .q_l(xx0_unused[11]), .q(din_d1[13]), | |
| 177 | .siclk(siclk), | |
| 178 | .soclk(soclk)); | |
| 179 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx12 (.scan_in(so[11]), .scan_out(so[12]), .l1clk(l1clk_in), .d(din[14]), .latout(xx_unused[12]), .q_l(xx0_unused[12]), .q(din_d1[14]), | |
| 180 | .siclk(siclk), | |
| 181 | .soclk(soclk)); | |
| 182 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx13 (.scan_in(so[12]), .scan_out(so[13]), .l1clk(l1clk_in), .d(din[15]), .latout(xx_unused[13]), .q_l(xx0_unused[13]), .q(din_d1[15]), | |
| 183 | .siclk(siclk), | |
| 184 | .soclk(soclk)); | |
| 185 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx14 (.scan_in(so[13]), .scan_out(so[14]), .l1clk(l1clk_in), .d(din[16]), .latout(xx_unused[14]), .q_l(xx0_unused[14]), .q(din_d1[16]), | |
| 186 | .siclk(siclk), | |
| 187 | .soclk(soclk)); | |
| 188 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx15 (.scan_in(so[14]), .scan_out(so[15]), .l1clk(l1clk_in), .d(din[17]), .latout(xx_unused[15]), .q_l(xx0_unused[15]), .q(din_d1[17]), | |
| 189 | .siclk(siclk), | |
| 190 | .soclk(soclk)); | |
| 191 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx16 (.scan_in(so[15]), .scan_out(so[16]), .l1clk(l1clk_in), .d(din[7]), .latout(xx_unused[16]), .q_l(xx0_unused[16]), .q(din_d1[7]), | |
| 192 | .siclk(siclk), | |
| 193 | .soclk(soclk)); | |
| 194 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx17 (.scan_in(so[16]), .scan_out(so[17]), .l1clk(l1clk_in), .d(din[8]), .latout(xx_unused[17]), .q_l(xx0_unused[17]), .q(din_d1[8]), | |
| 195 | .siclk(siclk), | |
| 196 | .soclk(soclk)); | |
| 197 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx18 (.scan_in(so[17]), .scan_out(so[18]), .l1clk(l1clk_in), .d(din[18]), .latout(xx_unused[18]), .q_l(xx0_unused[18]), .q(din_d1[18]), | |
| 198 | .siclk(siclk), | |
| 199 | .soclk(soclk)); | |
| 200 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx19 (.scan_in(so[18]), .scan_out(so[19]), .l1clk(l1clk_in), .d(din[19]), .latout(xx_unused[19]), .q_l(xx0_unused[19]), .q(din_d1[19]), | |
| 201 | .siclk(siclk), | |
| 202 | .soclk(soclk)); | |
| 203 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx20 (.scan_in(so[19]), .scan_out(so[20]), .l1clk(l1clk_in), .d(din[20]), .latout(xx_unused[20]), .q_l(xx0_unused[20]), .q(din_d1[20]), | |
| 204 | .siclk(siclk), | |
| 205 | .soclk(soclk)); | |
| 206 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx21 (.scan_in(so[20]), .scan_out(so[21]), .l1clk(l1clk_in), .d(din[21]), .latout(xx_unused[21]), .q_l(xx0_unused[21]), .q(din_d1[21]), | |
| 207 | .siclk(siclk), | |
| 208 | .soclk(soclk)); | |
| 209 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx22 (.scan_in(so[21]), .scan_out(so[22]), .l1clk(l1clk_in), .d(din[22]), .latout(xx_unused[22]), .q_l(xx0_unused[22]), .q(din_d1[22]), | |
| 210 | .siclk(siclk), | |
| 211 | .soclk(soclk)); | |
| 212 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx23 (.scan_in(so[22]), .scan_out(so[23]), .l1clk(l1clk_in), .d(din[23]), .latout(xx_unused[23]), .q_l(xx0_unused[23]), .q(din_d1[23]), | |
| 213 | .siclk(siclk), | |
| 214 | .soclk(soclk)); | |
| 215 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx24 (.scan_in(so[23]), .scan_out(so[24]), .l1clk(l1clk_in), .d(din[24]), .latout(xx_unused[24]), .q_l(xx0_unused[24]), .q(din_d1[24]), | |
| 216 | .siclk(siclk), | |
| 217 | .soclk(soclk)); | |
| 218 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx25 (.scan_in(so[24]), .scan_out(so[25]), .l1clk(l1clk_in), .d(din[25]), .latout(xx_unused[25]), .q_l(xx0_unused[25]), .q(din_d1[25]), | |
| 219 | .siclk(siclk), | |
| 220 | .soclk(soclk)); | |
| 221 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx26 (.scan_in(so[25]), .scan_out(so[26]), .l1clk(l1clk_in), .d(din[26]), .latout(xx_unused[26]), .q_l(xx0_unused[26]), .q(din_d1[26]), | |
| 222 | .siclk(siclk), | |
| 223 | .soclk(soclk)); | |
| 224 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx27 (.scan_in(so[26]), .scan_out(so[27]), .l1clk(l1clk_in), .d(din[27]), .latout(xx_unused[27]), .q_l(xx0_unused[27]), .q(din_d1[27]), | |
| 225 | .siclk(siclk), | |
| 226 | .soclk(soclk)); | |
| 227 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx28 (.scan_in(so[27]), .scan_out(so[28]), .l1clk(l1clk_in), .d(din[28]), .latout(xx_unused[28]), .q_l(xx0_unused[28]), .q(din_d1[28]), | |
| 228 | .siclk(siclk), | |
| 229 | .soclk(soclk)); | |
| 230 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx29 (.scan_in(so[28]), .scan_out(so[29]), .l1clk(l1clk_in), .d(din[29]), .latout(xx_unused[29]), .q_l(xx0_unused[29]), .q(din_d1[29]), | |
| 231 | .siclk(siclk), | |
| 232 | .soclk(soclk)); | |
| 233 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx30 (.scan_in(so[29]), .scan_out(so[30]), .l1clk(l1clk_in), .d(din[30]), .latout(xx_unused[30]), .q_l(xx0_unused[30]), .q(din_d1[30]), | |
| 234 | .siclk(siclk), | |
| 235 | .soclk(soclk)); | |
| 236 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx31 (.scan_in(so[30]), .scan_out(so[31]), .l1clk(l1clk_in), .d(din[31]), .latout(xx_unused[31]), .q_l(xx0_unused[31]), .q(din_d1[31]), | |
| 237 | .siclk(siclk), | |
| 238 | .soclk(soclk)); | |
| 239 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx32 (.scan_in(so[31]), .scan_out(so[32]), .l1clk(l1clk_in), .d(din[32]), .latout(xx_unused[32]), .q_l(xx0_unused[32]), .q(din_d1[32]), | |
| 240 | .siclk(siclk), | |
| 241 | .soclk(soclk)); | |
| 242 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx33 (.scan_in(so[32]), .scan_out(so[33]), .l1clk(l1clk_in), .d(din[33]), .latout(xx_unused[33]), .q_l(xx0_unused[33]), .q(din_d1[33]), | |
| 243 | .siclk(siclk), | |
| 244 | .soclk(soclk)); | |
| 245 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx34 (.scan_in(so[33]), .scan_out(so[34]), .l1clk(l1clk_in), .d(din[34]), .latout(xx_unused[34]), .q_l(xx0_unused[34]), .q(din_d1[34]), | |
| 246 | .siclk(siclk), | |
| 247 | .soclk(soclk)); | |
| 248 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx35 (.scan_in(so[34]), .scan_out(so[35]), .l1clk(l1clk_in), .d(din[35]), .latout(xx_unused[35]), .q_l(xx0_unused[35]), .q(din_d1[35]), | |
| 249 | .siclk(siclk), | |
| 250 | .soclk(soclk)); | |
| 251 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx36 (.scan_in(so[35]), .scan_out(so[36]), .l1clk(l1clk_in), .d(din[36]), .latout(xx_unused[36]), .q_l(xx0_unused[36]), .q(din_d1[36]), | |
| 252 | .siclk(siclk), | |
| 253 | .soclk(soclk)); | |
| 254 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx37 (.scan_in(so[36]), .scan_out(so[37]), .l1clk(l1clk_in), .d(din[37]), .latout(xx_unused[37]), .q_l(xx0_unused[37]), .q(din_d1[37]), | |
| 255 | .siclk(siclk), | |
| 256 | .soclk(soclk)); | |
| 257 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx38 (.scan_in(so[37]), .scan_out(so[38]), .l1clk(l1clk_in), .d(din[38]), .latout(xx_unused[38]), .q_l(xx0_unused[38]), .q(din_d1[38]), | |
| 258 | .siclk(siclk), | |
| 259 | .soclk(soclk)); | |
| 260 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx39 (.scan_in(so[38]), .scan_out(so[39]), .l1clk(l1clk_in), .d(din[39]), .latout(xx_unused[39]), .q_l(xx0_unused[39]), .q(din_d1[39]), | |
| 261 | .siclk(siclk), | |
| 262 | .soclk(soclk)); | |
| 263 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx40 (.scan_in(so[39]), .scan_out(so[40]), .l1clk(l1clk_in), .d(din[40]), .latout(xx_unused[40]), .q_l(xx0_unused[40]), .q(din_d1[40]), | |
| 264 | .siclk(siclk), | |
| 265 | .soclk(soclk)); | |
| 266 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx41 (.scan_in(so[40]), .scan_out(so[41]), .l1clk(l1clk_in), .d(din[41]), .latout(xx_unused[41]), .q_l(xx0_unused[41]), .q(din_d1[41]), | |
| 267 | .siclk(siclk), | |
| 268 | .soclk(soclk)); | |
| 269 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx42 (.scan_in(so[41]), .scan_out(so[42]), .l1clk(l1clk_in), .d(key[41]), .latout(key_d1[41]), .q_l(xx0_unused[42]), .q(xx_unused[42]), | |
| 270 | .siclk(siclk), | |
| 271 | .soclk(soclk)); | |
| 272 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx43 (.scan_in(so[42]), .scan_out(so[43]), .l1clk(l1clk_in), .d(key[40]), .latout(key_d1[40]), .q_l(xx0_unused[43]), .q(xx_unused[43]), | |
| 273 | .siclk(siclk), | |
| 274 | .soclk(soclk)); | |
| 275 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx44 (.scan_in(so[43]), .scan_out(so[44]), .l1clk(l1clk_in), .d(key[39]), .latout(key_d1[39]), .q_l(xx0_unused[44]), .q(xx_unused[44]), | |
| 276 | .siclk(siclk), | |
| 277 | .soclk(soclk)); | |
| 278 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx45 (.scan_in(so[44]), .scan_out(so[45]), .l1clk(l1clk_in), .d(key[38]), .latout(key_d1[38]), .q_l(xx0_unused[45]), .q(xx_unused[45]), | |
| 279 | .siclk(siclk), | |
| 280 | .soclk(soclk)); | |
| 281 | ||
| 282 | ||
| 283 | ||
| 284 | ||
| 285 | ||
| 286 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx46 (.scan_in(so[45]), .scan_out(lkup_so), .l1clk(l1clk_in), .d(lookup_en), .latout(lookup_en_d1), .q_l(xx0_unused[46]), .q(xx_unused[46]), | |
| 287 | .siclk(siclk), | |
| 288 | .soclk(soclk)); | |
| 289 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx47 (.scan_in(lkup_so), .scan_out(so[46]), .l1clk(l1clk_in), .d(key[37]), .latout(key_d1[37]), .q_l(xx0_unused[47]), .q(xx_unused[47]), | |
| 290 | .siclk(siclk), | |
| 291 | .soclk(soclk)); | |
| 292 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx48 (.scan_in(so[46]), .scan_out(so[47]), .l1clk(l1clk_in), .d(key[36]), .latout(key_d1[36]), .q_l(xx0_unused[48]), .q(xx_unused[48]), | |
| 293 | .siclk(siclk), | |
| 294 | .soclk(soclk)); | |
| 295 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx49 (.scan_in(so[47]), .scan_out(so[48]), .l1clk(l1clk_in), .d(key[35]), .latout(key_d1[35]), .q_l(xx0_unused[49]), .q(xx_unused[49]), | |
| 296 | .siclk(siclk), | |
| 297 | .soclk(soclk)); | |
| 298 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx50 (.scan_in(so[48]), .scan_out(so[49]), .l1clk(l1clk_in), .d(key[34]), .latout(key_d1[34]), .q_l(xx0_unused[50]), .q(xx_unused[50]), | |
| 299 | .siclk(siclk), | |
| 300 | .soclk(soclk)); | |
| 301 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx51 (.scan_in(so[49]), .scan_out(so[50]), .l1clk(l1clk_in), .d(key[33]), .latout(key_d1[33]), .q_l(xx0_unused[51]), .q(xx_unused[51]), | |
| 302 | .siclk(siclk), | |
| 303 | .soclk(soclk)); | |
| 304 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx52 (.scan_in(so[50]), .scan_out(so[51]), .l1clk(l1clk_in), .d(key[32]), .latout(key_d1[32]), .q_l(xx0_unused[52]), .q(xx_unused[52]), | |
| 305 | .siclk(siclk), | |
| 306 | .soclk(soclk)); | |
| 307 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx53 (.scan_in(so[51]), .scan_out(so[52]), .l1clk(l1clk_in), .d(key[31]), .latout(key_d1[31]), .q_l(xx0_unused[53]), .q(xx_unused[53]), | |
| 308 | .siclk(siclk), | |
| 309 | .soclk(soclk)); | |
| 310 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx54 (.scan_in(so[52]), .scan_out(so[53]), .l1clk(l1clk_in), .d(key[30]), .latout(key_d1[30]), .q_l(xx0_unused[54]), .q(xx_unused[54]), | |
| 311 | .siclk(siclk), | |
| 312 | .soclk(soclk)); | |
| 313 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx55 (.scan_in(so[53]), .scan_out(so[54]), .l1clk(l1clk_in), .d(key[29]), .latout(key_d1[29]), .q_l(xx0_unused[55]), .q(xx_unused[55]), | |
| 314 | .siclk(siclk), | |
| 315 | .soclk(soclk)); | |
| 316 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx56 (.scan_in(so[54]), .scan_out(so[55]), .l1clk(l1clk_in), .d(key[28]), .latout(key_d1[28]), .q_l(xx0_unused[56]), .q(xx_unused[56]), | |
| 317 | .siclk(siclk), | |
| 318 | .soclk(soclk)); | |
| 319 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx57 (.scan_in(so[55]), .scan_out(so[56]), .l1clk(l1clk_in), .d(key[27]), .latout(key_d1[27]), .q_l(xx0_unused[57]), .q(xx_unused[57]), | |
| 320 | .siclk(siclk), | |
| 321 | .soclk(soclk)); | |
| 322 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx58 (.scan_in(so[56]), .scan_out(so[57]), .l1clk(l1clk_in), .d(key[26]), .latout(key_d1[26]), .q_l(xx0_unused[58]), .q(xx_unused[58]), | |
| 323 | .siclk(siclk), | |
| 324 | .soclk(soclk)); | |
| 325 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx59 (.scan_in(so[57]), .scan_out(so[58]), .l1clk(l1clk_in), .d(key[25]), .latout(key_d1[25]), .q_l(xx0_unused[59]), .q(xx_unused[59]), | |
| 326 | .siclk(siclk), | |
| 327 | .soclk(soclk)); | |
| 328 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx60 (.scan_in(so[58]), .scan_out(so[59]), .l1clk(l1clk_in), .d(key[24]), .latout(key_d1[24]), .q_l(xx0_unused[60]), .q(xx_unused[60]), | |
| 329 | .siclk(siclk), | |
| 330 | .soclk(soclk)); | |
| 331 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx61 (.scan_in(so[59]), .scan_out(so[60]), .l1clk(l1clk_in), .d(key[23]), .latout(key_d1[23]), .q_l(xx0_unused[70]), .q(xx_unused[70]), | |
| 332 | .siclk(siclk), | |
| 333 | .soclk(soclk)); | |
| 334 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx62 (.scan_in(so[60]), .scan_out(so[61]), .l1clk(l1clk_in), .d(key[22]), .latout(key_d1[22]), .q_l(xx0_unused[71]), .q(xx_unused[71]), | |
| 335 | .siclk(siclk), | |
| 336 | .soclk(soclk)); | |
| 337 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx63 (.scan_in(so[61]), .scan_out(so[62]), .l1clk(l1clk_in), .d(key[21]), .latout(key_d1[21]), .q_l(xx0_unused[72]), .q(xx_unused[72]), | |
| 338 | .siclk(siclk), | |
| 339 | .soclk(soclk)); | |
| 340 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx64 (.scan_in(so[62]), .scan_out(so[63]), .l1clk(l1clk_in), .d(key[20]), .latout(key_d1[20]), .q_l(xx0_unused[73]), .q(xx_unused[73]), | |
| 341 | .siclk(siclk), | |
| 342 | .soclk(soclk)); | |
| 343 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx65 (.scan_in(so[63]), .scan_out(so[64]), .l1clk(l1clk_in), .d(key[19]), .latout(key_d1[19]), .q_l(xx0_unused[74]), .q(xx_unused[74]), | |
| 344 | .siclk(siclk), | |
| 345 | .soclk(soclk)); | |
| 346 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx66 (.scan_in(so[64]), .scan_out(so[65]), .l1clk(l1clk_in), .d(key[18]), .latout(key_d1[18]), .q_l(xx0_unused[75]), .q(xx_unused[75]), | |
| 347 | .siclk(siclk), | |
| 348 | .soclk(soclk)); | |
| 349 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx67 (.scan_in(so[65]), .scan_out(so[66]), .l1clk(l1clk_in), .d(key[8]), .latout(key_d1[8]), .q_l(xx0_unused[76]), .q(xx_unused[76]), | |
| 350 | .siclk(siclk), | |
| 351 | .soclk(soclk)); | |
| 352 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx68 (.scan_in(so[66]), .scan_out(so[67]), .l1clk(l1clk_in), .d(key[7]), .latout(key_d1[7]), .q_l(xx0_unused[77]), .q(xx_unused[77]), | |
| 353 | .siclk(siclk), | |
| 354 | .soclk(soclk)); | |
| 355 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx69 (.scan_in(so[67]), .scan_out(so[68]), .l1clk(l1clk_in), .d(key[17]), .latout(key_d1[17]), .q_l(xx0_unused[78]), .q(xx_unused[78]), | |
| 356 | .siclk(siclk), | |
| 357 | .soclk(soclk)); | |
| 358 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx70 (.scan_in(so[68]), .scan_out(so[69]), .l1clk(l1clk_in), .d(key[16]), .latout(key_d1[16]), .q_l(xx0_unused[79]), .q(xx_unused[79]), | |
| 359 | .siclk(siclk), | |
| 360 | .soclk(soclk)); | |
| 361 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx71 (.scan_in(so[69]), .scan_out(so[70]), .l1clk(l1clk_in), .d(key[15]), .latout(key_d1[15]), .q_l(xx0_unused[80]), .q(xx_unused[80]), | |
| 362 | .siclk(siclk), | |
| 363 | .soclk(soclk)); | |
| 364 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx72 (.scan_in(so[70]), .scan_out(so[71]), .l1clk(l1clk_in), .d(key[14]), .latout(key_d1[14]), .q_l(xx0_unused[81]), .q(xx_unused[81]), | |
| 365 | .siclk(siclk), | |
| 366 | .soclk(soclk)); | |
| 367 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx73 (.scan_in(so[71]), .scan_out(so[72]), .l1clk(l1clk_in), .d(key[13]), .latout(key_d1[13]), .q_l(xx0_unused[82]), .q(xx_unused[82]), | |
| 368 | .siclk(siclk), | |
| 369 | .soclk(soclk)); | |
| 370 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx74 (.scan_in(so[72]), .scan_out(so[73]), .l1clk(l1clk_in), .d(key[12]), .latout(key_d1[12]), .q_l(xx0_unused[83]), .q(xx_unused[83]), | |
| 371 | .siclk(siclk), | |
| 372 | .soclk(soclk)); | |
| 373 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx75 (.scan_in(so[73]), .scan_out(so[74]), .l1clk(l1clk_in), .d(key[11]), .latout(key_d1[11]), .q_l(xx0_unused[84]), .q(xx_unused[84]), | |
| 374 | .siclk(siclk), | |
| 375 | .soclk(soclk)); | |
| 376 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx76 (.scan_in(so[74]), .scan_out(so[75]), .l1clk(l1clk_in), .d(key[10]), .latout(key_d1[10]), .q_l(xx0_unused[85]), .q(xx_unused[85]), | |
| 377 | .siclk(siclk), | |
| 378 | .soclk(soclk)); | |
| 379 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx77 (.scan_in(so[75]), .scan_out(so[76]), .l1clk(l1clk_in), .d(key[9]), .latout(key_d1[9]), .q_l(xx0_unused[86]), .q(xx_unused[86]), | |
| 380 | .siclk(siclk), | |
| 381 | .soclk(soclk)); | |
| 382 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx78 (.scan_in(so[76]), .scan_out(so[77]), .l1clk(l1clk_in), .d(read_en), .latout(mb_ren_d1), .q_l(xx0_unused[87]), .q(xx_unused[87]), | |
| 383 | .siclk(siclk), | |
| 384 | .soclk(soclk)); | |
| 385 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx79 (.scan_in(so[77]), .scan_out(so[78]), .l1clk(l1clk_in), .d(write_en), .latout(mb_wen_d1), .q_l(xx0_unused[88]), .q(xx_unused[88]), | |
| 386 | .siclk(siclk), | |
| 387 | .soclk(soclk)); | |
| 388 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx80 (.scan_in(so[78]), .scan_out(so[79]), .l1clk(l1clk_in), .d(adr_r[0]), .latout(adr_r_d1[0]), .q_l(xx0_unused[89]), .q(xx_unused[89]), | |
| 389 | .siclk(siclk), | |
| 390 | .soclk(soclk)); | |
| 391 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx81 (.scan_in(so[79]), .scan_out(so[80]), .l1clk(l1clk_in), .d(adr_r[1]), .latout(adr_r_d1[1]), .q_l(xx0_unused[90]), .q(xx_unused[90]), | |
| 392 | .siclk(siclk), | |
| 393 | .soclk(soclk)); | |
| 394 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx82 (.scan_in(so[80]), .scan_out(so[81]), .l1clk(l1clk_in), .d(adr_r[2]), .latout(adr_r_d1[2]), .q_l(xx0_unused[91]), .q(xx_unused[91]), | |
| 395 | .siclk(siclk), | |
| 396 | .soclk(soclk)); | |
| 397 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx83 (.scan_in(so[81]), .scan_out(so[82]), .l1clk(l1clk_in), .d(adr_r[3]), .latout(adr_r_d1[3]), .q_l(xx0_unused[92]), .q(xx_unused[92]), | |
| 398 | .siclk(siclk), | |
| 399 | .soclk(soclk)); | |
| 400 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx84 (.scan_in(so[82]), .scan_out(so[83]), .l1clk(l1clk_in), .d(adr_w[0]), .latout(adr_w_d1[0]), .q_l(xx0_unused[93]), .q(xx_unused[93]), | |
| 401 | .siclk(siclk), | |
| 402 | .soclk(soclk)); | |
| 403 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx85 (.scan_in(so[83]), .scan_out(so[84]), .l1clk(l1clk_in), .d(adr_w[1]), .latout(adr_w_d1[1]), .q_l(xx0_unused[94]), .q(xx_unused[94]), | |
| 404 | .siclk(siclk), | |
| 405 | .soclk(soclk)); | |
| 406 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx86 (.scan_in(so[84]), .scan_out(so[85]), .l1clk(l1clk_in), .d(adr_w[2]), .latout(adr_w_d1[2]), .q_l(xx0_unused[95]), .q(xx_unused[95]), | |
| 407 | .siclk(siclk), | |
| 408 | .soclk(soclk)); | |
| 409 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx87 (.scan_in(so[85]), .scan_out(so[86]), .l1clk(l1clk_in), .d(adr_w[3]), .latout(adr_w_d1[3]), .q_l(xx0_unused[96]), .q(xx_unused[96]), | |
| 410 | .siclk(siclk), | |
| 411 | .soclk(soclk)); | |
| 412 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx88 (.scan_in(so[86]), .scan_out(so[87]), .l1clk(l1clk_in), .d(adr_r[4]), .latout(adr_r_d1[4]), .q_l(xx0_unused[97]), .q(xx_unused[97]), | |
| 413 | .siclk(siclk), | |
| 414 | .soclk(soclk)); | |
| 415 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx89 (.scan_in(so[87]), .scan_out(so[88]), .l1clk(l1clk_in), .d(adr_r[5]), .latout(adr_r_d1[5]), .q_l(xx0_unused[98]), .q(xx_unused[98]), | |
| 416 | .siclk(siclk), | |
| 417 | .soclk(soclk)); | |
| 418 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx90 (.scan_in(so[88]), .scan_out(so[89]), .l1clk(l1clk_in), .d(adr_r[6]), .latout(adr_r_d1[6]), .q_l(xx0_unused[99]), .q(xx_unused[99]), | |
| 419 | .siclk(siclk), | |
| 420 | .soclk(soclk)); | |
| 421 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx91 (.scan_in(so[89]), .scan_out(so[90]), .l1clk(l1clk_in), .d(adr_r[7]), .latout(adr_r_d1[7]), .q_l(xx0_unused[100]), .q(xx_unused[100]), | |
| 422 | .siclk(siclk), | |
| 423 | .soclk(soclk)); | |
| 424 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx92 (.scan_in(so[90]), .scan_out(so[91]), .l1clk(l1clk_in), .d(adr_w[4]), .latout(adr_w_d1[4]), .q_l(xx0_unused[101]), .q(xx_unused[101]), | |
| 425 | .siclk(siclk), | |
| 426 | .soclk(soclk)); | |
| 427 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx93 (.scan_in(so[91]), .scan_out(so[92]), .l1clk(l1clk_in), .d(adr_w[5]), .latout(adr_w_d1[5]), .q_l(xx0_unused[102]), .q(xx_unused[102]), | |
| 428 | .siclk(siclk), | |
| 429 | .soclk(soclk)); | |
| 430 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx94 (.scan_in(so[92]), .scan_out(so[93]), .l1clk(l1clk_in), .d(adr_w[6]), .latout(adr_w_d1[6]), .q_l(xx0_unused[103]), .q(xx_unused[103]), | |
| 431 | .siclk(siclk), | |
| 432 | .soclk(soclk)); | |
| 433 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx95 (.scan_in(so[93]), .scan_out(so[94]), .l1clk(l1clk_in), .d(adr_w[7]), .latout(adr_w_d1[7]), .q_l(xx0_unused[104]), .q(xx_unused[104]), | |
| 434 | .siclk(siclk), | |
| 435 | .soclk(soclk)); | |
| 436 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx96 (.scan_in(so[94]), .scan_out(so[95]), .l1clk(l1clk_in), .d(adr_r[11]), .latout(adr_r_d1[11]), .q_l(xx0_unused[105]), .q(xx_unused[105]), | |
| 437 | .siclk(siclk), | |
| 438 | .soclk(soclk)); | |
| 439 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx97 (.scan_in(so[95]), .scan_out(so[96]), .l1clk(l1clk_in), .d(adr_r[10]), .latout(adr_r_d1[10]), .q_l(xx0_unused[106]), .q(xx_unused[106]), | |
| 440 | .siclk(siclk), | |
| 441 | .soclk(soclk)); | |
| 442 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx98 (.scan_in(so[96]), .scan_out(so[97]), .l1clk(l1clk_in), .d(adr_r[9]), .latout(adr_r_d1[9]), .q_l(xx0_unused[107]), .q(xx_unused[107]), | |
| 443 | .siclk(siclk), | |
| 444 | .soclk(soclk)); | |
| 445 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx99 (.scan_in(so[97]), .scan_out(so[98]), .l1clk(l1clk_in), .d(adr_r[8]), .latout(adr_r_d1[8]), .q_l(xx0_unused[108]), .q(xx_unused[108]), | |
| 446 | .siclk(siclk), | |
| 447 | .soclk(soclk)); | |
| 448 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx100 (.scan_in(so[98]), .scan_out(so[99]), .l1clk(l1clk_in), .d(adr_w[11]), .latout(adr_w_d1[11]), .q_l(xx0_unused[109]), .q(xx_unused[109]), | |
| 449 | .siclk(siclk), | |
| 450 | .soclk(soclk)); | |
| 451 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx101 (.scan_in(so[99]), .scan_out(so[100]), .l1clk(l1clk_in), .d(adr_w[10]), .latout(adr_w_d1[10]), .q_l(xx0_unused[110]), .q(xx_unused[110]), | |
| 452 | .siclk(siclk), | |
| 453 | .soclk(soclk)); | |
| 454 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx102 (.scan_in(so[100]), .scan_out(so[101]), .l1clk(l1clk_in), .d(adr_w[9]), .latout(adr_w_d1[9]), .q_l(xx0_unused[111]), .q(xx_unused[111]), | |
| 455 | .siclk(siclk), | |
| 456 | .soclk(soclk)); | |
| 457 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx103 (.scan_in(so[101]), .scan_out(so[102]), .l1clk(l1clk_in), .d(adr_w[8]), .latout(adr_w_d1[8]), .q_l(xx0_unused[112]), .q(xx_unused[112]), | |
| 458 | .siclk(siclk), | |
| 459 | .soclk(soclk)); | |
| 460 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx104 (.scan_in(so[102]), .scan_out(so[103]), .l1clk(l1clk_in), .d(adr_r[15]), .latout(adr_r_d1[15]),.q_l(xx0_unused[113]), .q(xx_unused[113]), | |
| 461 | .siclk(siclk), | |
| 462 | .soclk(soclk)); | |
| 463 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx105 (.scan_in(so[103]), .scan_out(so[104]), .l1clk(l1clk_in), .d(adr_r[14]), .latout(adr_r_d1[14]),.q_l(xx0_unused[114]), .q(xx_unused[114]), | |
| 464 | .siclk(siclk), | |
| 465 | .soclk(soclk)); | |
| 466 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx106 (.scan_in(so[104]), .scan_out(so[105]), .l1clk(l1clk_in), .d(adr_r[13]), .latout(adr_r_d1[13]),.q_l(xx0_unused[115]), .q(xx_unused[115]), | |
| 467 | .siclk(siclk), | |
| 468 | .soclk(soclk)); | |
| 469 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx107 (.scan_in(so[105]), .scan_out(so[106]), .l1clk(l1clk_in), .d(adr_r[12]), .latout(adr_r_d1[12]),.q_l(xx0_unused[116]), .q(xx_unused[116]), | |
| 470 | .siclk(siclk), | |
| 471 | .soclk(soclk)); | |
| 472 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx108 (.scan_in(so[106]), .scan_out(so[107]), .l1clk(l1clk_in), .d(adr_w[15]), .latout(adr_w_d1[15]),.q_l(xx0_unused[117]), .q(xx_unused[117]), | |
| 473 | .siclk(siclk), | |
| 474 | .soclk(soclk)); | |
| 475 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx109 (.scan_in(so[107]), .scan_out(so[108]), .l1clk(l1clk_in), .d(adr_w[14]), .latout(adr_w_d1[14]),.q_l(xx0_unused[118]), .q(xx_unused[118]), | |
| 476 | .siclk(siclk), | |
| 477 | .soclk(soclk)); | |
| 478 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx110 (.scan_in(so[108]), .scan_out(so[109]), .l1clk(l1clk_in), .d(adr_w[13]), .latout(adr_w_d1[13]),.q_l(xx0_unused[119]), .q(xx_unused[119]), | |
| 479 | .siclk(siclk), | |
| 480 | .soclk(soclk)); | |
| 481 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx111 (.scan_in(so[109]), .scan_out(so[110]), .l1clk(l1clk_in), .d(adr_w[12]), .latout(adr_w_d1[12]),.q_l(xx0_unused[120]), .q(xx_unused[120]), | |
| 482 | .siclk(siclk), | |
| 483 | .soclk(soclk)); | |
| 484 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx112 (.scan_in(so[110]), .scan_out(so[111]), .l1clk(l1clk_in), .d(adr_r[16]), .latout(adr_r_d1[16]),.q_l(xx0_unused[121]), .q(xx_unused[121]), | |
| 485 | .siclk(siclk), | |
| 486 | .soclk(soclk)); | |
| 487 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx113 (.scan_in(so[111]), .scan_out(so[112]), .l1clk(l1clk_in), .d(adr_r[17]), .latout(adr_r_d1[17]),.q_l(xx0_unused[122]), .q(xx_unused[122]), | |
| 488 | .siclk(siclk), | |
| 489 | .soclk(soclk)); | |
| 490 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx114 (.scan_in(so[112]), .scan_out(so[113]), .l1clk(l1clk_in), .d(adr_r[18]), .latout(adr_r_d1[18]),.q_l(xx0_unused[123]), .q(xx_unused[123]), | |
| 491 | .siclk(siclk), | |
| 492 | .soclk(soclk)); | |
| 493 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx115 (.scan_in(so[113]), .scan_out(so[114]), .l1clk(l1clk_in), .d(adr_r[19]), .latout(adr_r_d1[19]),.q_l(xx0_unused[124]), .q(xx_unused[124]), | |
| 494 | .siclk(siclk), | |
| 495 | .soclk(soclk)); | |
| 496 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx116 (.scan_in(so[114]), .scan_out(so[115]), .l1clk(l1clk_in), .d(adr_w[16]), .latout(adr_w_d1[16]),.q_l(xx0_unused[125]), .q(xx_unused[125]), | |
| 497 | .siclk(siclk), | |
| 498 | .soclk(soclk)); | |
| 499 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx117 (.scan_in(so[115]), .scan_out(so[116]), .l1clk(l1clk_in), .d(adr_w[17]), .latout(adr_w_d1[17]),.q_l(xx0_unused[126]), .q(xx_unused[126]), | |
| 500 | .siclk(siclk), | |
| 501 | .soclk(soclk)); | |
| 502 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx118 (.scan_in(so[116]), .scan_out(so[117]), .l1clk(l1clk_in), .d(adr_w[18]), .latout(adr_w_d1[18]),.q_l(xx0_unused[127]), .q(xx_unused[127]), | |
| 503 | .siclk(siclk), | |
| 504 | .soclk(soclk)); | |
| 505 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx119 (.scan_in(so[117]), .scan_out(so[118]), .l1clk(l1clk_in), .d(adr_w[19]), .latout(adr_w_d1[19]),.q_l(xx0_unused[128]), .q(xx_unused[128]), | |
| 506 | .siclk(siclk), | |
| 507 | .soclk(soclk)); | |
| 508 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx120 (.scan_in(so[118]), .scan_out(so[119]), .l1clk(l1clk_in), .d(adr_r[20]), .latout(adr_r_d1[20]),.q_l(xx0_unused[129]), .q(xx_unused[129]), | |
| 509 | .siclk(siclk), | |
| 510 | .soclk(soclk)); | |
| 511 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx121 (.scan_in(so[119]), .scan_out(so[120]), .l1clk(l1clk_in), .d(adr_r[21]), .latout(adr_r_d1[21]),.q_l(xx0_unused[130]), .q(xx_unused[130]), | |
| 512 | .siclk(siclk), | |
| 513 | .soclk(soclk)); | |
| 514 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx122 (.scan_in(so[120]), .scan_out(so[121]), .l1clk(l1clk_in), .d(adr_r[22]), .latout(adr_r_d1[22]),.q_l(xx0_unused[131]), .q(xx_unused[131]), | |
| 515 | .siclk(siclk), | |
| 516 | .soclk(soclk)); | |
| 517 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx123 (.scan_in(so[121]), .scan_out(so[122]), .l1clk(l1clk_in), .d(adr_r[23]), .latout(adr_r_d1[23]),.q_l(xx0_unused[132]), .q(xx_unused[132]), | |
| 518 | .siclk(siclk), | |
| 519 | .soclk(soclk)); | |
| 520 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx124 (.scan_in(so[122]), .scan_out(so[123]), .l1clk(l1clk_in), .d(adr_w[20]), .latout(adr_w_d1[20]),.q_l(xx0_unused[133]), .q(xx_unused[133]), | |
| 521 | .siclk(siclk), | |
| 522 | .soclk(soclk)); | |
| 523 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx125 (.scan_in(so[123]), .scan_out(so[124]), .l1clk(l1clk_in), .d(adr_w[21]), .latout(adr_w_d1[21]),.q_l(xx0_unused[134]), .q(xx_unused[134]), | |
| 524 | .siclk(siclk), | |
| 525 | .soclk(soclk)); | |
| 526 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx126 (.scan_in(so[124]), .scan_out(so[125]), .l1clk(l1clk_in), .d(adr_w[22]), .latout(adr_w_d1[22]),.q_l(xx0_unused[135]), .q(xx_unused[135]), | |
| 527 | .siclk(siclk), | |
| 528 | .soclk(soclk)); | |
| 529 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx127 (.scan_in(so[125]), .scan_out(so[126]), .l1clk(l1clk_in), .d(adr_w[23]), .latout(adr_w_d1[23]),.q_l(xx0_unused[136]), .q(xx_unused[136]), | |
| 530 | .siclk(siclk), | |
| 531 | .soclk(soclk)); | |
| 532 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx128 (.scan_in(so[126]), .scan_out(so[127]), .l1clk(l1clk_in), .d(adr_r[27]), .latout(adr_r_d1[27]),.q_l(xx0_unused[137]), .q(xx_unused[137]), | |
| 533 | .siclk(siclk), | |
| 534 | .soclk(soclk)); | |
| 535 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx129 (.scan_in(so[127]), .scan_out(so[128]), .l1clk(l1clk_in), .d(adr_r[26]), .latout(adr_r_d1[26]),.q_l(xx0_unused[138]), .q(xx_unused[138]), | |
| 536 | .siclk(siclk), | |
| 537 | .soclk(soclk)); | |
| 538 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx130 (.scan_in(so[128]), .scan_out(so[129]), .l1clk(l1clk_in), .d(adr_r[25]), .latout(adr_r_d1[25]),.q_l(xx0_unused[139]), .q(xx_unused[139]), | |
| 539 | .siclk(siclk), | |
| 540 | .soclk(soclk)); | |
| 541 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx131 (.scan_in(so[129]), .scan_out(so[130]), .l1clk(l1clk_in), .d(adr_r[24]), .latout(adr_r_d1[24]),.q_l(xx0_unused[140]), .q(xx_unused[140]), | |
| 542 | .siclk(siclk), | |
| 543 | .soclk(soclk)); | |
| 544 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx132 (.scan_in(so[130]), .scan_out(so[131]), .l1clk(l1clk_in), .d(adr_w[27]), .latout(adr_w_d1[27]),.q_l(xx0_unused[141]), .q(xx_unused[141]), | |
| 545 | .siclk(siclk), | |
| 546 | .soclk(soclk)); | |
| 547 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx133 (.scan_in(so[131]), .scan_out(so[132]), .l1clk(l1clk_in), .d(adr_w[26]), .latout(adr_w_d1[26]),.q_l(xx0_unused[142]), .q(xx_unused[142]), | |
| 548 | .siclk(siclk), | |
| 549 | .soclk(soclk)); | |
| 550 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx134 (.scan_in(so[132]), .scan_out(so[133]), .l1clk(l1clk_in), .d(adr_w[25]), .latout(adr_w_d1[25]),.q_l(xx0_unused[143]), .q(xx_unused[143]), | |
| 551 | .siclk(siclk), | |
| 552 | .soclk(soclk)); | |
| 553 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx135 (.scan_in(so[133]), .scan_out(so[134]), .l1clk(l1clk_in), .d(adr_w[24]), .latout(adr_w_d1[24]),.q_l(xx0_unused[144]), .q(xx_unused[144]), | |
| 554 | .siclk(siclk), | |
| 555 | .soclk(soclk)); | |
| 556 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx136 (.scan_in(so[134]), .scan_out(so[135]), .l1clk(l1clk_in), .d(adr_r[31]), .latout(adr_r_d1[31]),.q_l(xx0_unused[145]), .q(xx_unused[145]), | |
| 557 | .siclk(siclk), | |
| 558 | .soclk(soclk)); | |
| 559 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx137 (.scan_in(so[135]), .scan_out(so[136]), .l1clk(l1clk_in), .d(adr_r[30]), .latout(adr_r_d1[30]),.q_l(xx0_unused[146]), .q(xx_unused[146]), | |
| 560 | .siclk(siclk), | |
| 561 | .soclk(soclk)); | |
| 562 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx138 (.scan_in(so[136]), .scan_out(so[137]), .l1clk(l1clk_in), .d(adr_r[29]), .latout(adr_r_d1[29]),.q_l(xx0_unused[147]), .q(xx_unused[147]), | |
| 563 | .siclk(siclk), | |
| 564 | .soclk(soclk)); | |
| 565 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx139 (.scan_in(so[137]), .scan_out(so[138]), .l1clk(l1clk_in), .d(adr_r[28]), .latout(adr_r_d1[28]),.q_l(xx0_unused[148]), .q(xx_unused[148]), | |
| 566 | .siclk(siclk), | |
| 567 | .soclk(soclk)); | |
| 568 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx140 (.scan_in(so[138]), .scan_out(so[139]), .l1clk(l1clk_in), .d(adr_w[31]), .latout(adr_w_d1[31]),.q_l(xx0_unused[149]), .q(xx_unused[149]), | |
| 569 | .siclk(siclk), | |
| 570 | .soclk(soclk)); | |
| 571 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx141 (.scan_in(so[139]), .scan_out(so[140]), .l1clk(l1clk_in), .d(adr_w[30]), .latout(adr_w_d1[30]),.q_l(xx0_unused[150]), .q(xx_unused[150]), | |
| 572 | .siclk(siclk), | |
| 573 | .soclk(soclk)); | |
| 574 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx142 (.scan_in(so[140]), .scan_out(so[141]), .l1clk(l1clk_in), .d(adr_w[29]), .latout(adr_w_d1[29]),.q_l(xx0_unused[151]), .q(xx_unused[151]), | |
| 575 | .siclk(siclk), | |
| 576 | .soclk(soclk)); | |
| 577 | n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 xx143 (.scan_in(so[141]), .scan_out(so[142]), .l1clk(l1clk_in), .d(adr_w[28]), .latout(adr_w_d1[28]),.q_l(xx0_unused[152]), .q(xx_unused[152]), | |
| 578 | .siclk(siclk), | |
| 579 | .soclk(soclk)); | |
| 580 | ||
| 581 | ||
| 582 | /////////////////// | |
| 583 | /// Memory array //// | |
| 584 | ||
| 585 | n2_com_cm_32x40_cust_array array ( | |
| 586 | .l1clk(l1clk_en), | |
| 587 | .wr_en (mb_wen_d1), | |
| 588 | .rd_en (mb_ren_d1), | |
| 589 | .wr_addr(adr_w_d1[31:0]), | |
| 590 | .rd_addr(adr_r_d1[31:0]), | |
| 591 | .din(din_d1[41:0]), | |
| 592 | .dout(dout_array[41:0]), | |
| 593 | .tcu_array_wr_inhibit(tcu_array_wr_inhibit), | |
| 594 | .lookup_en(lookup_en_d1), | |
| 595 | .key(key_d1[41:7]), | |
| 596 | .match(match[31:0]), | |
| 597 | .match_idx(match_idx[31:0]), | |
| 598 | .bypass(tcu_array_bypass) | |
| 599 | ); | |
| 600 | ||
| 601 | // fixscan start: | |
| 602 | //assign ff_din_scanin = scan_in ; | |
| 603 | //assign ff_wr_en_scanin = ff_din_scanout ; | |
| 604 | //assign ff_wr_adr_scanin = ff_wr_en_scanout ; | |
| 605 | //assign ff_rd_adr_scanin = ff_wr_adr_scanout ; | |
| 606 | //assign ff_ren_scanin = ff_rd_adr_scanout ; | |
| 607 | //assign ff_lookup_en_scanin = ff_ren_scanout ; | |
| 608 | //assign ff_key_scanin = ff_lookup_en_scanout ; | |
| 609 | assign scan_out = so[142]; //ff_key_scanout ; | |
| 610 | // fixscan end: | |
| 611 | ||
| 612 | // synopsys translate_on | |
| 613 | ||
| 614 | endmodule | |
| 615 | ||
| 616 | ||
| 617 | module n2_com_cm_32x40_cust_array ( | |
| 618 | l1clk, | |
| 619 | wr_en, | |
| 620 | rd_en, | |
| 621 | tcu_array_wr_inhibit, | |
| 622 | key, | |
| 623 | wr_addr, | |
| 624 | rd_addr, | |
| 625 | din, | |
| 626 | lookup_en, | |
| 627 | bypass, | |
| 628 | dout, | |
| 629 | match, | |
| 630 | match_idx); | |
| 631 | ||
| 632 | input l1clk; | |
| 633 | input wr_en; | |
| 634 | input rd_en; | |
| 635 | ||
| 636 | input tcu_array_wr_inhibit; | |
| 637 | input [41:7] key; | |
| 638 | input [31:0] wr_addr; | |
| 639 | input [31:0] rd_addr; | |
| 640 | input [41:0] din; | |
| 641 | input lookup_en; | |
| 642 | input bypass; | |
| 643 | ||
| 644 | output [41:0] dout; | |
| 645 | output [31:0] match; | |
| 646 | output [31:0] match_idx; | |
| 647 | ||
| 648 | ||
| 649 | ||
| 650 | ||
| 651 | ||
| 652 | reg [41:0] mb_cam_data[31:0] ; | |
| 653 | reg [41:0] dout; | |
| 654 | reg [41:0] tmp_addr ; | |
| 655 | reg [41:0] tmp_addr0 ; | |
| 656 | reg [41:0] tmp_addr1 ; | |
| 657 | reg [41:0] tmp_addr2 ; | |
| 658 | reg [41:0] tmp_addr3 ; | |
| 659 | reg [41:0] tmp_addr4 ; | |
| 660 | reg [41:0] tmp_addr5 ; | |
| 661 | reg [41:0] tmp_addr6 ; | |
| 662 | reg [41:0] tmp_addr7 ; | |
| 663 | reg [41:0] tmp_addr8 ; | |
| 664 | reg [41:0] tmp_addr9 ; | |
| 665 | reg [41:0] tmp_addr10 ; | |
| 666 | reg [41:0] tmp_addr11 ; | |
| 667 | reg [41:0] tmp_addr12 ; | |
| 668 | reg [41:0] tmp_addr13 ; | |
| 669 | reg [41:0] tmp_addr14 ; | |
| 670 | reg [41:0] tmp_addr15 ; | |
| 671 | reg [41:0] tmp_addr16; | |
| 672 | reg [41:0] tmp_addr17; | |
| 673 | reg [41:0] tmp_addr18; | |
| 674 | reg [41:0] tmp_addr19; | |
| 675 | reg [41:0] tmp_addr20; | |
| 676 | reg [41:0] tmp_addr21; | |
| 677 | reg [41:0] tmp_addr22; | |
| 678 | reg [41:0] tmp_addr23; | |
| 679 | reg [41:0] tmp_addr24; | |
| 680 | reg [41:0] tmp_addr25; | |
| 681 | reg [41:0] tmp_addr26; | |
| 682 | reg [41:0] tmp_addr27; | |
| 683 | reg [41:0] tmp_addr28; | |
| 684 | reg [41:0] tmp_addr29; | |
| 685 | reg [41:0] tmp_addr30; | |
| 686 | reg [41:0] tmp_addr31; | |
| 687 | ||
| 688 | wire [31:0] match ; | |
| 689 | wire [31:0] match_idx ; | |
| 690 | reg [31:0] match_p ; | |
| 691 | reg [31:0] match_idx_p ; | |
| 692 | ||
| 693 | wire [41:0] tmp_data0; | |
| 694 | wire [41:0] tmp_data1; | |
| 695 | wire [41:0] tmp_data2; | |
| 696 | wire [41:0] tmp_data3; | |
| 697 | wire [41:0] tmp_data4; | |
| 698 | wire [41:0] tmp_data5; | |
| 699 | wire [41:0] tmp_data6; | |
| 700 | wire [41:0] tmp_data7; | |
| 701 | wire [41:0] tmp_data8; | |
| 702 | wire [41:0] tmp_data9; | |
| 703 | wire [41:0] tmp_data10; | |
| 704 | wire [41:0] tmp_data11; | |
| 705 | wire [41:0] tmp_data12; | |
| 706 | wire [41:0] tmp_data13; | |
| 707 | wire [41:0] tmp_data14; | |
| 708 | wire [41:0] tmp_data15; | |
| 709 | wire [41:0] tmp_data16; | |
| 710 | wire [41:0] tmp_data17; | |
| 711 | wire [41:0] tmp_data18; | |
| 712 | wire [41:0] tmp_data19; | |
| 713 | wire [41:0] tmp_data20; | |
| 714 | wire [41:0] tmp_data21; | |
| 715 | wire [41:0] tmp_data22; | |
| 716 | wire [41:0] tmp_data23; | |
| 717 | wire [41:0] tmp_data24; | |
| 718 | wire [41:0] tmp_data25; | |
| 719 | wire [41:0] tmp_data26; | |
| 720 | wire [41:0] tmp_data27; | |
| 721 | wire [41:0] tmp_data28; | |
| 722 | wire [41:0] tmp_data29; | |
| 723 | wire [41:0] tmp_data30; | |
| 724 | wire [41:0] tmp_data31; | |
| 725 | // bamick, added wires above to allow us to view array contents in SSF | |
| 726 | ||
| 727 | `ifndef NOINITMEM | |
| 728 | /////////////////////////////////////// | |
| 729 | // Initialize the arrays. // | |
| 730 | /////////////////////////////////////// | |
| 731 | integer n; | |
| 732 | initial begin | |
| 733 | for (n = 0; n < 32; n = n + 1) begin | |
| 734 | mb_cam_data[n] = {42 {1'b0}}; | |
| 735 | end | |
| 736 | end | |
| 737 | `endif | |
| 738 | ||
| 739 | assign tmp_data0 = mb_cam_data[0]; | |
| 740 | assign tmp_data1 = mb_cam_data[1]; | |
| 741 | assign tmp_data2 = mb_cam_data[2]; | |
| 742 | assign tmp_data3 = mb_cam_data[3]; | |
| 743 | assign tmp_data4 = mb_cam_data[4]; | |
| 744 | assign tmp_data5 = mb_cam_data[5]; | |
| 745 | assign tmp_data6 = mb_cam_data[6]; | |
| 746 | assign tmp_data7 = mb_cam_data[7]; | |
| 747 | assign tmp_data8 = mb_cam_data[8]; | |
| 748 | assign tmp_data9 = mb_cam_data[9]; | |
| 749 | assign tmp_data10 = mb_cam_data[10]; | |
| 750 | assign tmp_data11 = mb_cam_data[11]; | |
| 751 | assign tmp_data12 = mb_cam_data[12]; | |
| 752 | assign tmp_data13 = mb_cam_data[13]; | |
| 753 | assign tmp_data14 = mb_cam_data[14]; | |
| 754 | assign tmp_data15 = mb_cam_data[15]; | |
| 755 | assign tmp_data16 = mb_cam_data[16]; | |
| 756 | assign tmp_data17 = mb_cam_data[17]; | |
| 757 | assign tmp_data18 = mb_cam_data[18]; | |
| 758 | assign tmp_data19 = mb_cam_data[19]; | |
| 759 | assign tmp_data20 = mb_cam_data[20]; | |
| 760 | assign tmp_data21 = mb_cam_data[21]; | |
| 761 | assign tmp_data22 = mb_cam_data[22]; | |
| 762 | assign tmp_data23 = mb_cam_data[23]; | |
| 763 | assign tmp_data24 = mb_cam_data[24]; | |
| 764 | assign tmp_data25 = mb_cam_data[25]; | |
| 765 | assign tmp_data26 = mb_cam_data[26]; | |
| 766 | assign tmp_data27 = mb_cam_data[27]; | |
| 767 | assign tmp_data28 = mb_cam_data[28]; | |
| 768 | assign tmp_data29 = mb_cam_data[29]; | |
| 769 | assign tmp_data30 = mb_cam_data[30]; | |
| 770 | assign tmp_data31 = mb_cam_data[31]; | |
| 771 | // bamick, added assign statements to allow use to view array contents in SSF | |
| 772 | ||
| 773 | integer i; | |
| 774 | ||
| 775 | assign match = match_p ; | |
| 776 | assign match_idx = match_idx_p ; | |
| 777 | ||
| 778 | //0in kndr -var wr_addr[31:0] -active wr_en | |
| 779 | //0in kndr -var rd_addr[31:0] -active rd_en | |
| 780 | //0in one_hot -var rd_addr[31:0] -active (|rd_addr & rd_en) -group mbist_mode | |
| 781 | //0in one_hot -var wr_addr[31:0] -active (|wr_addr & wr_en) -group mbist_mode | |
| 782 | ||
| 783 | // CAM OPERATION | |
| 784 | always @( /*AUTOSENSE*/ /*memory or*/ wr_addr or key or | |
| 785 | tmp_data0 or tmp_data1 or tmp_data2 or tmp_data3 or tmp_data4 or tmp_data5 or | |
| 786 | tmp_data6 or tmp_data7 or tmp_data8 or tmp_data9 or tmp_data10 or tmp_data11 or | |
| 787 | tmp_data12 or tmp_data13 or tmp_data14 or tmp_data15 or tmp_data16 or tmp_data17 or | |
| 788 | tmp_data18 or tmp_data19 or tmp_data20 or tmp_data21 or tmp_data22 or tmp_data23 or | |
| 789 | tmp_data24 or tmp_data25 or tmp_data26 or tmp_data27 or tmp_data28 or tmp_data29 or | |
| 790 | tmp_data30 or tmp_data31 or | |
| 791 | lookup_en or wr_en or bypass or tcu_array_wr_inhibit or l1clk) begin | |
| 792 | ||
| 793 | ||
| 794 | ||
| 795 | #0 | |
| 796 | ||
| 797 | ||
| 798 | ||
| 799 | if (bypass) begin | |
| 800 | match_p = 32'b0 ; | |
| 801 | match_idx_p = 32'hffffffff; | |
| 802 | end | |
| 803 | else if ( l1clk & lookup_en & ~tcu_array_wr_inhibit) begin | |
| 804 | ||
| 805 | ||
| 806 | tmp_addr0 = tmp_data0; | |
| 807 | match_p[0] = ( wr_en & wr_addr[0] ) ? 1'bx : | |
| 808 | ( tmp_addr0[41:7] == key[41:7] ) ; | |
| 809 | match_idx_p[0] = ( wr_en & wr_addr[0] ) ? 1'bx : | |
| 810 | ( tmp_addr0[17:9] == key[17:9] ) ; | |
| 811 | ||
| 812 | tmp_addr1 = tmp_data1; | |
| 813 | match_p[1] = ( wr_en & wr_addr[1] ) ? 1'bx : | |
| 814 | ( tmp_addr1[41:7] == key[41:7] ) ; | |
| 815 | match_idx_p[1] = ( wr_en & wr_addr[1] ) ? 1'bx : | |
| 816 | ( tmp_addr1[17:9] == key[17:9] ) ; | |
| 817 | ||
| 818 | tmp_addr2 = tmp_data2; | |
| 819 | match_p[2] = ( wr_en & wr_addr[2] ) ? 1'bx : | |
| 820 | ( tmp_addr2[41:7] == key[41:7] ) ; | |
| 821 | match_idx_p[2] = ( wr_en & wr_addr[2] ) ? 1'bx : | |
| 822 | ( tmp_addr2[17:9] == key[17:9] ) ; | |
| 823 | ||
| 824 | tmp_addr3 = tmp_data3; | |
| 825 | match_p[3] = ( wr_en & wr_addr[3] ) ? 1'bx : | |
| 826 | ( tmp_addr3[41:7] == key[41:7] ) ; | |
| 827 | match_idx_p[3] = ( wr_en & wr_addr[3] ) ? 1'bx : | |
| 828 | ( tmp_addr3[17:9] == key[17:9] ) ; | |
| 829 | ||
| 830 | tmp_addr4 = tmp_data4; | |
| 831 | match_p[4] = ( wr_en & wr_addr[4] ) ? 1'bx : | |
| 832 | ( tmp_addr4[41:7] == key[41:7] ) ; | |
| 833 | match_idx_p[4] = ( wr_en & wr_addr[4] ) ? 1'bx : | |
| 834 | ( tmp_addr4[17:9] == key[17:9] ) ; | |
| 835 | ||
| 836 | tmp_addr5 = tmp_data5; | |
| 837 | match_p[5] = ( wr_en & wr_addr[5] ) ? 1'bx : | |
| 838 | ( tmp_addr5[41:7] == key[41:7] ) ; | |
| 839 | match_idx_p[5] = ( wr_en & wr_addr[5] ) ? 1'bx : | |
| 840 | ( tmp_addr5[17:9] == key[17:9] ) ; | |
| 841 | ||
| 842 | tmp_addr6 = tmp_data6; | |
| 843 | match_p[6] = ( wr_en & wr_addr[6] ) ? 1'bx : | |
| 844 | ( tmp_addr6[41:7] == key[41:7] ) ; | |
| 845 | match_idx_p[6] = ( wr_en & wr_addr[6] ) ? 1'bx : | |
| 846 | ( tmp_addr6[17:9] == key[17:9] ) ; | |
| 847 | ||
| 848 | tmp_addr7 = tmp_data7; | |
| 849 | match_p[7] = ( wr_en & wr_addr[7] ) ? 1'bx : | |
| 850 | ( tmp_addr7[41:7] == key[41:7] ) ; | |
| 851 | match_idx_p[7] = ( wr_en & wr_addr[7] ) ? 1'bx : | |
| 852 | ( tmp_addr7[17:9] == key[17:9] ) ; | |
| 853 | ||
| 854 | tmp_addr8 = tmp_data8; | |
| 855 | match_p[8] = ( wr_en & wr_addr[8] ) ? 1'bx : | |
| 856 | ( tmp_addr8[41:7] == key[41:7] ) ; | |
| 857 | match_idx_p[8] = ( wr_en & wr_addr[8] ) ? 1'bx : | |
| 858 | ( tmp_addr8[17:9] == key[17:9] ) ; | |
| 859 | ||
| 860 | tmp_addr9 = tmp_data9; | |
| 861 | match_p[9] = ( wr_en & wr_addr[9] ) ? 1'bx : | |
| 862 | ( tmp_addr9[41:7] == key[41:7] ) ; | |
| 863 | match_idx_p[9] = ( wr_en & wr_addr[9] ) ? 1'bx : | |
| 864 | ( tmp_addr9[17:9] == key[17:9] ) ; | |
| 865 | ||
| 866 | tmp_addr10 = tmp_data10; | |
| 867 | match_p[10] = ( wr_en & wr_addr[10] ) ? 1'bx : | |
| 868 | ( tmp_addr10[41:7] == key[41:7] ) ; | |
| 869 | match_idx_p[10] = ( wr_en & wr_addr[10] ) ? 1'bx : | |
| 870 | ( tmp_addr10[17:9] == key[17:9] ) ; | |
| 871 | ||
| 872 | tmp_addr11 = tmp_data11; | |
| 873 | match_p[11] = ( wr_en & wr_addr[11] ) ? 1'bx : | |
| 874 | ( tmp_addr11[41:7] == key[41:7] ) ; | |
| 875 | match_idx_p[11] = ( wr_en & wr_addr[11] ) ? 1'bx : | |
| 876 | ( tmp_addr11[17:9] == key[17:9] ) ; | |
| 877 | ||
| 878 | tmp_addr12 = tmp_data12; | |
| 879 | match_p[12] = ( wr_en & wr_addr[12] ) ? 1'bx : | |
| 880 | ( tmp_addr12[41:7] == key[41:7] ) ; | |
| 881 | match_idx_p[12] = ( wr_en & wr_addr[12] ) ? 1'bx : | |
| 882 | ( tmp_addr12[17:9] == key[17:9] ) ; | |
| 883 | ||
| 884 | tmp_addr13 = tmp_data13; | |
| 885 | match_p[13] = ( wr_en & wr_addr[13] ) ? 1'bx : | |
| 886 | ( tmp_addr13[41:7] == key[41:7] ) ; | |
| 887 | match_idx_p[13] = ( wr_en & wr_addr[13] ) ? 1'bx : | |
| 888 | ( tmp_addr13[17:9] == key[17:9] ) ; | |
| 889 | ||
| 890 | tmp_addr14 = tmp_data14; | |
| 891 | match_p[14] = ( wr_en & wr_addr[14] ) ? 1'bx : | |
| 892 | ( tmp_addr14[41:7] == key[41:7] ) ; | |
| 893 | match_idx_p[14] = ( wr_en & wr_addr[14] ) ? 1'bx : | |
| 894 | ( tmp_addr14[17:9] == key[17:9] ) ; | |
| 895 | ||
| 896 | tmp_addr15 = tmp_data15; | |
| 897 | match_p[15] = ( wr_en & wr_addr[15] ) ? 1'bx : | |
| 898 | ( tmp_addr15[41:7] == key[41:7] ) ; | |
| 899 | match_idx_p[15] = ( wr_en & wr_addr[15] ) ? 1'bx : | |
| 900 | ( tmp_addr15[17:9] == key[17:9] ) ; | |
| 901 | ||
| 902 | // BS & SR 11/04/03, MB grows to 32 | |
| 903 | ||
| 904 | tmp_addr16 = tmp_data16; | |
| 905 | match_p[16] = ( wr_en & wr_addr[16] ) ? 1'bx : ( tmp_addr16[41:7] == key[41:7] ) ; | |
| 906 | match_idx_p[16] = ( wr_en & wr_addr[16] ) ? 1'bx : ( tmp_addr16[17:9] == key[17:9] ) ; | |
| 907 | ||
| 908 | tmp_addr17 = tmp_data17; | |
| 909 | match_p[17] = ( wr_en & wr_addr[17] ) ? 1'bx : ( tmp_addr17[41:7] == key[41:7] ) ; | |
| 910 | match_idx_p[17] = ( wr_en & wr_addr[17] ) ? 1'bx : ( tmp_addr17[17:9] == key[17:9] ) ; | |
| 911 | ||
| 912 | tmp_addr18 = tmp_data18; | |
| 913 | match_p[18] = ( wr_en & wr_addr[18] ) ? 1'bx : ( tmp_addr18[41:7] == key[41:7] ) ; | |
| 914 | match_idx_p[18] = ( wr_en & wr_addr[18] ) ? 1'bx : ( tmp_addr18[17:9] == key[17:9] ) ; | |
| 915 | ||
| 916 | tmp_addr19 = tmp_data19; | |
| 917 | match_p[19] = ( wr_en & wr_addr[19] ) ? 1'bx : ( tmp_addr19[41:7] == key[41:7] ) ; | |
| 918 | match_idx_p[19] = ( wr_en & wr_addr[19] ) ? 1'bx : ( tmp_addr19[17:9] == key[17:9] ) ; | |
| 919 | ||
| 920 | tmp_addr20 = tmp_data20; | |
| 921 | match_p[20] = ( wr_en & wr_addr[20] ) ? 1'bx : ( tmp_addr20[41:7] == key[41:7] ) ; | |
| 922 | match_idx_p[20] = ( wr_en & wr_addr[20] ) ? 1'bx : ( tmp_addr20[17:9] == key[17:9] ) ; | |
| 923 | ||
| 924 | tmp_addr21 = tmp_data21; | |
| 925 | match_p[21] = ( wr_en & wr_addr[21] ) ? 1'bx : ( tmp_addr21[41:7] == key[41:7] ) ; | |
| 926 | match_idx_p[21] = ( wr_en & wr_addr[21] ) ? 1'bx : ( tmp_addr21[17:9] == key[17:9] ) ; | |
| 927 | ||
| 928 | tmp_addr22 = tmp_data22; | |
| 929 | match_p[22] = ( wr_en & wr_addr[22] ) ? 1'bx : ( tmp_addr22[41:7] == key[41:7] ) ; | |
| 930 | match_idx_p[22] = ( wr_en & wr_addr[22] ) ? 1'bx : ( tmp_addr22[17:9] == key[17:9] ) ; | |
| 931 | ||
| 932 | tmp_addr23 = tmp_data23; | |
| 933 | match_p[23] = ( wr_en & wr_addr[23] ) ? 1'bx : ( tmp_addr23[41:7] == key[41:7] ) ; | |
| 934 | match_idx_p[23] = ( wr_en & wr_addr[23] ) ? 1'bx : ( tmp_addr23[17:9] == key[17:9] ) ; | |
| 935 | ||
| 936 | tmp_addr24 = tmp_data24; | |
| 937 | match_p[24] = ( wr_en & wr_addr[24] ) ? 1'bx : ( tmp_addr24[41:7] == key[41:7] ) ; | |
| 938 | match_idx_p[24] = ( wr_en & wr_addr[24] ) ? 1'bx : ( tmp_addr24[17:9] == key[17:9] ) ; | |
| 939 | ||
| 940 | tmp_addr25 = tmp_data25; | |
| 941 | match_p[25] = ( wr_en & wr_addr[25] ) ? 1'bx : ( tmp_addr25[41:7] == key[41:7] ) ; | |
| 942 | match_idx_p[25] = ( wr_en & wr_addr[25] ) ? 1'bx : ( tmp_addr25[17:9] == key[17:9] ) ; | |
| 943 | ||
| 944 | tmp_addr26 = tmp_data26; | |
| 945 | match_p[26] = ( wr_en & wr_addr[26] ) ? 1'bx : ( tmp_addr26[41:7] == key[41:7] ) ; | |
| 946 | match_idx_p[26] = ( wr_en & wr_addr[26] ) ? 1'bx : ( tmp_addr26[17:9] == key[17:9] ) ; | |
| 947 | ||
| 948 | tmp_addr27 = tmp_data27; | |
| 949 | match_p[27] = ( wr_en & wr_addr[27] ) ? 1'bx : ( tmp_addr27[41:7] == key[41:7] ) ; | |
| 950 | match_idx_p[27] = ( wr_en & wr_addr[27] ) ? 1'bx : ( tmp_addr27[17:9] == key[17:9] ) ; | |
| 951 | ||
| 952 | ||
| 953 | tmp_addr28 = tmp_data28; | |
| 954 | match_p[28] = ( wr_en & wr_addr[28] ) ? 1'bx : ( tmp_addr28[41:7] == key[41:7] ) ; | |
| 955 | match_idx_p[28] = ( wr_en & wr_addr[28] ) ? 1'bx : ( tmp_addr28[17:9] == key[17:9] ) ; | |
| 956 | ||
| 957 | tmp_addr29 = tmp_data29; | |
| 958 | match_p[29] = ( wr_en & wr_addr[29] ) ? 1'bx : ( tmp_addr29[41:7] == key[41:7] ) ; | |
| 959 | match_idx_p[29] = ( wr_en & wr_addr[29] ) ? 1'bx : ( tmp_addr29[17:9] == key[17:9] ) ; | |
| 960 | ||
| 961 | tmp_addr30 = tmp_data30; | |
| 962 | match_p[30] = ( wr_en & wr_addr[30] ) ? 1'bx : ( tmp_addr30[41:7] == key[41:7] ) ; | |
| 963 | match_idx_p[30] = ( wr_en & wr_addr[30] ) ? 1'bx : ( tmp_addr30[17:9] == key[17:9] ) ; | |
| 964 | ||
| 965 | ||
| 966 | tmp_addr31 = tmp_data31; | |
| 967 | match_p[31] = ( wr_en & wr_addr[31] ) ? 1'bx : ( tmp_addr31[41:7] == key[41:7] ) ; | |
| 968 | match_idx_p[31] = ( wr_en & wr_addr[31] ) ? 1'bx : ( tmp_addr31[17:9] == key[17:9] ) ; | |
| 969 | ||
| 970 | ||
| 971 | end | |
| 972 | ||
| 973 | else if ( l1clk & ~lookup_en & ~tcu_array_wr_inhibit ) | |
| 974 | begin | |
| 975 | match_p = 32'b0; | |
| 976 | match_idx_p = 32'b0; | |
| 977 | end | |
| 978 | ||
| 979 | else | |
| 980 | begin | |
| 981 | end // do nothing, hold output latched during l1clk low | |
| 982 | ||
| 983 | end | |
| 984 | ||
| 985 | ||
| 986 | // READ AND WRITE HAPPEN in Phase 1. | |
| 987 | ||
| 988 | //bamick: convert write_disable to se; add bypass | |
| 989 | always @(l1clk or wr_addr or din or wr_en or tcu_array_wr_inhibit or bypass or rd_addr or rd_en) | |
| 990 | begin | |
| 991 | if (l1clk & wr_en & ~tcu_array_wr_inhibit & ~bypass) | |
| 992 | begin | |
| 993 | case(wr_addr ) | |
| 994 | 32'b0000_0000_0000_0000_0000_0000_0000_0000: ; // do nothing | |
| 995 | 32'b0000_0000_0000_0000_0000_0000_0000_0001: mb_cam_data[0] = din ; | |
| 996 | 32'b0000_0000_0000_0000_0000_0000_0000_0010: mb_cam_data[1] = din ; | |
| 997 | 32'b0000_0000_0000_0000_0000_0000_0000_0100: mb_cam_data[2] = din ; | |
| 998 | 32'b0000_0000_0000_0000_0000_0000_0000_1000: mb_cam_data[3] = din ; | |
| 999 | 32'b0000_0000_0000_0000_0000_0000_0001_0000: mb_cam_data[4] = din; | |
| 1000 | 32'b0000_0000_0000_0000_0000_0000_0010_0000: mb_cam_data[5] = din ; | |
| 1001 | 32'b0000_0000_0000_0000_0000_0000_0100_0000: mb_cam_data[6] = din ; | |
| 1002 | 32'b0000_0000_0000_0000_0000_0000_1000_0000: mb_cam_data[7] = din ; | |
| 1003 | 32'b0000_0000_0000_0000_0000_0001_0000_0000: mb_cam_data[8] = din ; | |
| 1004 | 32'b0000_0000_0000_0000_0000_0010_0000_0000: mb_cam_data[9] = din ; | |
| 1005 | 32'b0000_0000_0000_0000_0000_0100_0000_0000: mb_cam_data[10] = din ; | |
| 1006 | 32'b0000_0000_0000_0000_0000_1000_0000_0000: mb_cam_data[11] = din ; | |
| 1007 | 32'b0000_0000_0000_0000_0001_0000_0000_0000: mb_cam_data[12] = din ; | |
| 1008 | 32'b0000_0000_0000_0000_0010_0000_0000_0000: mb_cam_data[13] = din ; | |
| 1009 | 32'b0000_0000_0000_0000_0100_0000_0000_0000: mb_cam_data[14] = din ; | |
| 1010 | 32'b0000_0000_0000_0000_1000_0000_0000_0000: mb_cam_data[15] = din ; | |
| 1011 | 32'b0000_0000_0000_0001_0000_0000_0000_0000: mb_cam_data[16] = din ; | |
| 1012 | 32'b0000_0000_0000_0010_0000_0000_0000_0000: mb_cam_data[17] = din ; | |
| 1013 | 32'b0000_0000_0000_0100_0000_0000_0000_0000: mb_cam_data[18] = din ; | |
| 1014 | 32'b0000_0000_0000_1000_0000_0000_0000_0000: mb_cam_data[19] = din ; | |
| 1015 | 32'b0000_0000_0001_0000_0000_0000_0000_0000: mb_cam_data[20] = din; | |
| 1016 | 32'b0000_0000_0010_0000_0000_0000_0000_0000: mb_cam_data[21] = din ; | |
| 1017 | 32'b0000_0000_0100_0000_0000_0000_0000_0000: mb_cam_data[22] = din ; | |
| 1018 | 32'b0000_0000_1000_0000_0000_0000_0000_0000: mb_cam_data[23] = din ; | |
| 1019 | 32'b0000_0001_0000_0000_0000_0000_0000_0000: mb_cam_data[24] = din ; | |
| 1020 | 32'b0000_0010_0000_0000_0000_0000_0000_0000: mb_cam_data[25] = din ; | |
| 1021 | 32'b0000_0100_0000_0000_0000_0000_0000_0000: mb_cam_data[26] = din ; | |
| 1022 | 32'b0000_1000_0000_0000_0000_0000_0000_0000: mb_cam_data[27] = din ; | |
| 1023 | 32'b0001_0000_0000_0000_0000_0000_0000_0000: mb_cam_data[28] = din ; | |
| 1024 | 32'b0010_0000_0000_0000_0000_0000_0000_0000: mb_cam_data[29] = din ; | |
| 1025 | 32'b0100_0000_0000_0000_0000_0000_0000_0000: mb_cam_data[30] = din ; | |
| 1026 | 32'b1000_0000_0000_0000_0000_0000_0000_0000: mb_cam_data[31] = din ; | |
| 1027 | default: begin | |
| 1028 | // 0in <fire -message "FATAL ERROR: incorrect write wordline" -group mbist_mode | |
| 1029 | end | |
| 1030 | endcase | |
| 1031 | if(rd_en & (wr_addr==rd_addr)) | |
| 1032 | begin | |
| 1033 | // 0in <fire -message "ERROR : reading and writing to same location " -group mbist_mode | |
| 1034 | end | |
| 1035 | end | |
| 1036 | end | |
| 1037 | ||
| 1038 | // Notice that the renable is qualified with l1clk to take | |
| 1039 | // care that we do not read from the array if reset_l goes high | |
| 1040 | // during the negative phase of l1clk. | |
| 1041 | // | |
| 1042 | ||
| 1043 | // bamick, add bypass | |
| 1044 | always @( rd_addr or wr_addr or rd_en or wr_en or tcu_array_wr_inhibit or bypass or l1clk or | |
| 1045 | tmp_data0 or tmp_data1 or tmp_data2 or tmp_data3 or tmp_data4 or tmp_data5 or | |
| 1046 | tmp_data6 or tmp_data7 or tmp_data8 or tmp_data9 or tmp_data10 or tmp_data11 or | |
| 1047 | tmp_data12 or tmp_data13 or tmp_data14 or tmp_data15 or tmp_data16 or tmp_data17 or | |
| 1048 | tmp_data18 or tmp_data19 or tmp_data20 or tmp_data21 or tmp_data22 or tmp_data23 or | |
| 1049 | tmp_data24 or tmp_data25 or tmp_data26 or tmp_data27 or tmp_data28 or tmp_data29 or | |
| 1050 | tmp_data30 or tmp_data31 or | |
| 1051 | din) begin | |
| 1052 | if (bypass) begin | |
| 1053 | dout <= din; | |
| 1054 | end | |
| 1055 | ||
| 1056 | // bamick, IMPORTANT: not sure the below if matches circuit case, can't confirm yet | |
| 1057 | // as don't yet know how to run SSF to verify scan... | |
| 1058 | // I do think the value should be 42'b0 or hold the current value | |
| 1059 | ||
| 1060 | else if (rd_en & l1clk & tcu_array_wr_inhibit ) begin | |
| 1061 | // dout <= 42'h000_0000_0000 ; | |
| 1062 | end | |
| 1063 | ||
| 1064 | else if (rd_en & l1clk & ~tcu_array_wr_inhibit ) | |
| 1065 | begin | |
| 1066 | if ((wr_en) && (rd_addr == wr_addr)) | |
| 1067 | begin | |
| 1068 | dout <= 42'bx ; | |
| 1069 | // 0in <fire -message "ERROR : reading and writing to same location " -group mbist_mode | |
| 1070 | end | |
| 1071 | else | |
| 1072 | begin | |
| 1073 | case(rd_addr) | |
| 1074 | // match sense amp ckt behavior when no read wl is selected | |
| 1075 | //32'b0000_0000_0000_0000_0000_0000_0000_0000: dout <= 42'hff_ffff_ffff; | |
| 1076 | 32'b0000_0000_0000_0000_0000_0000_0000_0000: dout <= 42'b0; | |
| 1077 | 32'b0000_0000_0000_0000_0000_0000_0000_0001: dout <= tmp_data0 ; | |
| 1078 | 32'b0000_0000_0000_0000_0000_0000_0000_0010: dout <= tmp_data1 ; | |
| 1079 | 32'b0000_0000_0000_0000_0000_0000_0000_0100: dout <= tmp_data2 ; | |
| 1080 | 32'b0000_0000_0000_0000_0000_0000_0000_1000: dout <= tmp_data3 ; | |
| 1081 | 32'b0000_0000_0000_0000_0000_0000_0001_0000: dout <= tmp_data4 ; | |
| 1082 | 32'b0000_0000_0000_0000_0000_0000_0010_0000: dout <= tmp_data5 ; | |
| 1083 | 32'b0000_0000_0000_0000_0000_0000_0100_0000: dout <= tmp_data6 ; | |
| 1084 | 32'b0000_0000_0000_0000_0000_0000_1000_0000: dout <= tmp_data7 ; | |
| 1085 | 32'b0000_0000_0000_0000_0000_0001_0000_0000: dout <= tmp_data8 ; | |
| 1086 | 32'b0000_0000_0000_0000_0000_0010_0000_0000: dout <= tmp_data9 ; | |
| 1087 | 32'b0000_0000_0000_0000_0000_0100_0000_0000: dout <= tmp_data10 ; | |
| 1088 | 32'b0000_0000_0000_0000_0000_1000_0000_0000: dout <= tmp_data11 ; | |
| 1089 | 32'b0000_0000_0000_0000_0001_0000_0000_0000: dout <= tmp_data12 ; | |
| 1090 | 32'b0000_0000_0000_0000_0010_0000_0000_0000: dout <= tmp_data13 ; | |
| 1091 | 32'b0000_0000_0000_0000_0100_0000_0000_0000: dout <= tmp_data14 ; | |
| 1092 | 32'b0000_0000_0000_0000_1000_0000_0000_0000: dout <= tmp_data15 ; | |
| 1093 | 32'b0000_0000_0000_0001_0000_0000_0000_0000: dout <= tmp_data16 ; | |
| 1094 | 32'b0000_0000_0000_0010_0000_0000_0000_0000: dout <= tmp_data17 ; | |
| 1095 | 32'b0000_0000_0000_0100_0000_0000_0000_0000: dout <= tmp_data18 ; | |
| 1096 | 32'b0000_0000_0000_1000_0000_0000_0000_0000: dout <= tmp_data19 ; | |
| 1097 | 32'b0000_0000_0001_0000_0000_0000_0000_0000: dout <= tmp_data20 ; | |
| 1098 | 32'b0000_0000_0010_0000_0000_0000_0000_0000: dout <= tmp_data21 ; | |
| 1099 | 32'b0000_0000_0100_0000_0000_0000_0000_0000: dout <= tmp_data22 ; | |
| 1100 | 32'b0000_0000_1000_0000_0000_0000_0000_0000: dout <= tmp_data23 ; | |
| 1101 | 32'b0000_0001_0000_0000_0000_0000_0000_0000: dout <= tmp_data24 ; | |
| 1102 | 32'b0000_0010_0000_0000_0000_0000_0000_0000: dout <= tmp_data25 ; | |
| 1103 | 32'b0000_0100_0000_0000_0000_0000_0000_0000: dout <= tmp_data26 ; | |
| 1104 | 32'b0000_1000_0000_0000_0000_0000_0000_0000: dout <= tmp_data27 ; | |
| 1105 | 32'b0001_0000_0000_0000_0000_0000_0000_0000: dout <= tmp_data28 ; | |
| 1106 | 32'b0010_0000_0000_0000_0000_0000_0000_0000: dout <= tmp_data29 ; | |
| 1107 | 32'b0100_0000_0000_0000_0000_0000_0000_0000: dout <= tmp_data30 ; | |
| 1108 | 32'b1000_0000_0000_0000_0000_0000_0000_0000: dout <= tmp_data31 ; | |
| 1109 | default: | |
| 1110 | begin | |
| 1111 | dout <= 42'bx; | |
| 1112 | // 0in <fire -message "FATAL ERROR: incorrect read wordline" -group mbist_mode | |
| 1113 | end | |
| 1114 | endcase | |
| 1115 | end | |
| 1116 | end // of else if | |
| 1117 | end | |
| 1118 | endmodule | |
| 1119 | ||
| 1120 | ||
| 1121 | ||
| 1122 | ||
| 1123 | ||
| 1124 | ||
| 1125 | // any PARAMS parms go into naming of macro | |
| 1126 | ||
| 1127 | module n2_com_cm_32x40_cust_l1clkhdr_ctl_macro ( | |
| 1128 | l2clk, | |
| 1129 | l1en, | |
| 1130 | pce_ov, | |
| 1131 | stop, | |
| 1132 | se, | |
| 1133 | l1clk); | |
| 1134 | ||
| 1135 | ||
| 1136 | input l2clk; | |
| 1137 | input l1en; | |
| 1138 | input pce_ov; | |
| 1139 | input stop; | |
| 1140 | input se; | |
| 1141 | output l1clk; | |
| 1142 | ||
| 1143 | ||
| 1144 | ||
| 1145 | ||
| 1146 | ||
| 1147 | cl_sc1_l1hdr_8x c_0 ( | |
| 1148 | ||
| 1149 | ||
| 1150 | .l2clk(l2clk), | |
| 1151 | .pce(l1en), | |
| 1152 | .l1clk(l1clk), | |
| 1153 | .se(se), | |
| 1154 | .pce_ov(pce_ov), | |
| 1155 | .stop(stop) | |
| 1156 | ); | |
| 1157 | ||
| 1158 | ||
| 1159 | ||
| 1160 | endmodule | |
| 1161 | ||
| 1162 | ||
| 1163 | ||
| 1164 | ||
| 1165 | ||
| 1166 | ||
| 1167 | ||
| 1168 | ||
| 1169 | ||
| 1170 | // | |
| 1171 | // macro for cl_mc1_scm_msff_lat_{4}x flops | |
| 1172 | // | |
| 1173 | // | |
| 1174 | ||
| 1175 | ||
| 1176 | ||
| 1177 | ||
| 1178 | ||
| 1179 | module n2_com_cm_32x40_cust_scm_msff_lat_macro__width_1 ( | |
| 1180 | d, | |
| 1181 | scan_in, | |
| 1182 | l1clk, | |
| 1183 | siclk, | |
| 1184 | soclk, | |
| 1185 | latout, | |
| 1186 | scan_out, | |
| 1187 | q, | |
| 1188 | q_l); | |
| 1189 | input [0:0] d; | |
| 1190 | input scan_in; | |
| 1191 | input l1clk; | |
| 1192 | input siclk; | |
| 1193 | input soclk; | |
| 1194 | output [0:0] latout; | |
| 1195 | output scan_out; | |
| 1196 | output [0:0] q; | |
| 1197 | output [0:0] q_l; | |
| 1198 | ||
| 1199 | ||
| 1200 | ||
| 1201 | ||
| 1202 | ||
| 1203 | ||
| 1204 | scm_msff_lat #(1) d0_0 ( | |
| 1205 | .d(d[0:0]), | |
| 1206 | .si(scan_in), | |
| 1207 | .so(scan_out), | |
| 1208 | .l1clk(l1clk), | |
| 1209 | .siclk(siclk), | |
| 1210 | .soclk(soclk), | |
| 1211 | .q(q[0:0]), | |
| 1212 | .q_l(q_l[0:0]), | |
| 1213 | .latout(latout[0:0]) | |
| 1214 | ); | |
| 1215 | ||
| 1216 | ||
| 1217 | ||
| 1218 | ||
| 1219 | ||
| 1220 | ||
| 1221 | ||
| 1222 | ||
| 1223 | ||
| 1224 | ||
| 1225 | //place::generic_place($width,$stack,$left); | |
| 1226 | ||
| 1227 | endmodule | |
| 1228 | ||
| 1229 | ||
| 1230 | ||
| 1231 |