projects / OpenSPARC-T2-DV / blame
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Initial commit of OpenSPARC T2 design and verification files.
[OpenSPARC-T2-DV] / verif / env / ios / vera / ras / ios_injerr.vr
CommitLineData
86530b38
AT		 1// ========== Copyright Header Begin ==========================================
2//
3// OpenSPARC T2 Processor File: ios_injerr.vr
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#include <vera_defines.vrh>
36#include <VeraListProgram.vrh>
37#include <ListMacros.vrh>
38#include "ios_ras.if.vrh"
39#include "ios_ras_ports_binds.vrh"
40#include "std_display_class.vrh"
41#include "ios_err_packet.vrh"
42#include "verilog_tasks_InjErr.vri"
43
44ExternVeraList(ios_err_packet);
45
46class ios_ras_inj {
47// added this code for removing NIU
48#ifndef FC_NO_NIU_T2
49 niu_sii_inj_port niusii;
50#endif
51 dmu_sii_inj_port dmusii;
52#ifndef FC_NO_NIU_T2
53 sio_niu_inj_port sioniu;
54#endif
55 sio_dmu_inj_port siodmu;
56// sii_l2_inj_port siil2;
57 l2_sio_inj_port l2sio[8];
58 sii_ncu_inj_port siincu;
59// niu_ncu_inj_port niuncu;
60// ncu_dmu_inj_port ncudmu;
61
62 local bit [39:0] niu_tagtopa[];
63 local bit [39:0] dmu_tagtopa[];
64 local bit [15:0] dmu_credittotag[16];
65
66 StandardDisplay dbg;
67 local string myname;
68 local integer myid;
69 bit injector_on;
70
71 VeraList_ios_err_packet niusii_err_list, sioniu_err_list, dmusii_err_list, siodmu_err_list, l2sio_err_list[8],
72 siincu_err_list, dmuncu_wrack_err_list, ncudmu_mondo_err_list, siidmu_err_list;
73
74 VeraList_ios_err_packet injected_err_list;
75
76 task new(
77#ifndef FC_NO_NIU_T2
78 niu_sii_inj_port niusii,
79#endif
80 dmu_sii_inj_port dmusii,
81#ifndef FC_NO_NIU_T2
82 sio_niu_inj_port sioniu,
83#endif
84 sio_dmu_inj_port siodmu,
85 l2_sio_inj_port l2sio0, l2_sio_inj_port l2sio1, l2_sio_inj_port l2sio2, l2_sio_inj_port l2sio3,
86 l2_sio_inj_port l2sio4, l2_sio_inj_port l2sio5, l2_sio_inj_port l2sio6, l2_sio_inj_port l2sio7,
87 sii_ncu_inj_port siincu, StandardDisplay dbg);
88
89#ifndef FC_NO_NIU_T2
90 task niu_sii_err_inj();
91 task sio_niu_err_inj();
92#endif
93 task dmu_sii_err_inj();
94 task sio_dmu_err_inj();
95 task l2_sio_err_inj(integer bank);
96 task sii_ncu_err_inj();
97 task dmu_ncu_err_inj();
98 task ncu_dmu_err_inj();
99 task sii_dmu_err_inj();
100 task vinjector(SocErr_Type type);
101 task vl2injector(SocErr_Type type, integer bank);
102
103 function integer inj_err_packet(ios_err_packet err_pkt);
104 function integer inj_rand_err(SocErr_Type err_type, integer num_errs, integer weight );
105}
106
107task ios_ras_inj::new(
108#ifndef FC_NO_NIU_T2
109 niu_sii_inj_port niusii,
110#endif
111 dmu_sii_inj_port dmusii,
112#ifndef FC_NO_NIU_T2
113 sio_niu_inj_port sioniu,
114#endif
115 sio_dmu_inj_port siodmu,
116 l2_sio_inj_port l2sio0, l2_sio_inj_port l2sio1, l2_sio_inj_port l2sio2, l2_sio_inj_port l2sio3,
117 l2_sio_inj_port l2sio4, l2_sio_inj_port l2sio5, l2_sio_inj_port l2sio6, l2_sio_inj_port l2sio7,
118 sii_ncu_inj_port siincu, StandardDisplay dbg)
119{
120 integer i;
121
122#ifndef FC_NO_NIU_T2
123 this.niusii = niusii;
124 this.sioniu = sioniu;
125#endif
126 this.dmusii = dmusii;
127 this.siodmu = siodmu;
128 this.siincu = siincu;
129
130 this.l2sio[0] = l2sio0;
131 this.l2sio[1] = l2sio1;
132 this.l2sio[2] = l2sio2;
133 this.l2sio[3] = l2sio3;
134 this.l2sio[4] = l2sio4;
135 this.l2sio[5] = l2sio5;
136 this.l2sio[6] = l2sio6;
137 this.l2sio[7] = l2sio7;
138
139 this.myname = "IOS_errinj";
140 this.dbg = dbg;
141
142#ifndef FC_NO_NIU_T2
143 niusii_err_list = new();
144 sioniu_err_list = new();
145#endif
146 dmusii_err_list = new();
147 siodmu_err_list = new();
148 siincu_err_list = new();
149 for (i=0; i<8; i++)
150 l2sio_err_list[i] = new();
151 dmuncu_wrack_err_list = new();
152 ncudmu_mondo_err_list = new();
153 siidmu_err_list = new();
154 injected_err_list = new();
155 injector_on = 1;
156
157#ifndef FC_NO_NIU_T2
158 fork { niu_sii_err_inj(); } join none
159 fork { sio_niu_err_inj(); } join none
160#endif
161 fork { dmu_sii_err_inj(); } join none
162 fork { sio_dmu_err_inj(); } join none
163 fork { sii_ncu_err_inj(); } join none
164 fork { l2_sio_err_inj(0); } join none
165 fork { l2_sio_err_inj(1); } join none
166 fork { l2_sio_err_inj(2); } join none
167 fork { l2_sio_err_inj(3); } join none
168 fork { l2_sio_err_inj(4); } join none
169 fork { l2_sio_err_inj(5); } join none
170 fork { l2_sio_err_inj(6); } join none
171 fork { l2_sio_err_inj(7); } join none
172 fork { dmu_ncu_err_inj(); } join none
173 fork { ncu_dmu_err_inj(); } join none
174 fork { sii_dmu_err_inj(); } join none
175}
176
177function integer ios_ras_inj::inj_err_packet(ios_err_packet err_pkt)
178{
179 ios_err_packet tmp_pkt = err_pkt;
180 integer result = 1;
181
182 case (err_pkt.type) {
183#ifndef FC_NO_NIU_T2
184 NIUSII_CUE: niusii_err_list.push_back(tmp_pkt);
185 NIUSII_CCE: niusii_err_list.push_back(tmp_pkt);
186 NIUSII_AP: niusii_err_list.push_back(tmp_pkt);
187 NIUSII_DP: niusii_err_list.push_back(tmp_pkt);
188 NIUSII_CMDP: niusii_err_list.push_back(tmp_pkt);
189 NIUSII_IOAE: niusii_err_list.push_back(tmp_pkt);
190 NIUSII_IOUE: niusii_err_list.push_back(tmp_pkt);
191 SIONIU_DP: sioniu_err_list.push_back(tmp_pkt);
192 SIONIU_CUE: sioniu_err_list.push_back(tmp_pkt);
193 SIONIU_CCE: sioniu_err_list.push_back(tmp_pkt);
194#endif
195 DMUSII_CUE: dmusii_err_list.push_back(tmp_pkt);
196 DMUSII_CCE: dmusii_err_list.push_back(tmp_pkt);
197 DMUSII_AP: dmusii_err_list.push_back(tmp_pkt);
198 DMUSII_DP: dmusii_err_list.push_back(tmp_pkt);
199 DMUSII_BEP: dmusii_err_list.push_back(tmp_pkt);
200 DMUSII_CMDP: dmusii_err_list.push_back(tmp_pkt);
201 DMUSII_TOUT: dmusii_err_list.push_back(tmp_pkt);
202 DMUSII_IOAE: dmusii_err_list.push_back(tmp_pkt);
203 DMUSII_IOUE: dmusii_err_list.push_back(tmp_pkt);
204 SIODMU_DP: siodmu_err_list.push_back(tmp_pkt);
205 SIODMU_CUE: siodmu_err_list.push_back(tmp_pkt);
206 SIODMU_CCE: siodmu_err_list.push_back(tmp_pkt);
207 L2SIO_DP: l2sio_err_list[tmp_pkt.pa[8:6]].push_back(tmp_pkt);
208 L2SIO_EBIT: l2sio_err_list[tmp_pkt.pa[8:6]].push_back(tmp_pkt);
209 L2SIO_CUE: l2sio_err_list[tmp_pkt.pa[8:6]].push_back(tmp_pkt);
210 L2SIO_CCE: l2sio_err_list[tmp_pkt.pa[8:6]].push_back(tmp_pkt);
211 SIINCU_DP: siincu_err_list.push_back(tmp_pkt);
212 SIINCU_CUE: siincu_err_list.push_back(tmp_pkt);
213 SIINCU_CCE: siincu_err_list.push_back(tmp_pkt);
214 DMUNCU_WRACK_P: dmuncu_wrack_err_list.push_back(tmp_pkt);
215 NCUDMU_MONDO_IDP: ncudmu_mondo_err_list.push_back(tmp_pkt);
216 SIIDMU_WRACK_P: siidmu_err_list.push_back(tmp_pkt);
217
218 default: result = -1;
219 }
220 inj_err_packet = result;
221}
222
223function integer ios_ras_inj::inj_rand_err(SocErr_Type err_type, integer num_errs, integer weight)
224{
225 integer result = 1;
226 integer i, bank;
227 ios_err_packet tmp_pkt;
228
229 case (err_type) {
230#ifndef FC_NO_NIU_T2
231 NIUSII_CCE, NIUSII_CUE, NIUSII_AP, NIUSII_DP :
232 for (i=0; i<num_errs; i++)
233 {
234 tmp_pkt = new(err_type, 16'hFFFF, 40'h8000000000);
235 result = tmp_pkt.set_rand(weight);
236 niusii_err_list.push_back(tmp_pkt);
237 }
238 SIONIU_CCE: for (i=0; i<num_errs; i++)
239 {
240 tmp_pkt = new(SIONIU_CCE, 16'hFFFF, 40'h8000000000);
241 result = tmp_pkt.set_rand(weight);
242 sioniu_err_list.push_back(tmp_pkt);
243 }
244#endif
245 DMUSII_CCE, DMUSII_CUE, DMUSII_AP, DMUSII_DP :
246 for (i=0; i<num_errs; i++)
247 {
248 tmp_pkt = new(err_type, 16'hFFFF, 40'h8000000000);
249 result = tmp_pkt.set_rand(weight);
250 dmusii_err_list.push_back(tmp_pkt);
251 }
252 SIODMU_CCE: for (i=0; i<num_errs; i++)
253 {
254 tmp_pkt = new(SIODMU_CCE, 16'hFFFF, 40'h8000000000);
255 result = tmp_pkt.set_rand(weight);
256 siodmu_err_list.push_back(tmp_pkt);
257 }
258 L2SIO_CCE: for (i=0; i<num_errs; i++)
259 {
260 tmp_pkt = new(L2SIO_CCE, 16'hFFFF, 40'h8000000000);
261 result = tmp_pkt.set_rand(weight);
262 bank = random() % 8;
263 l2sio_err_list[bank].push_back(tmp_pkt);
264 }
265 SIINCU_CCE: for (i=0; i<num_errs; i++)
266 {
267 tmp_pkt = new(SIINCU_CCE, 16'hFFFF, 40'h8000000000);
268 result = tmp_pkt.set_rand(weight);
269 siincu_err_list.push_back(tmp_pkt);
270 }
271 default: result = -1;
272 }
273}
274
275#ifndef FC_NO_NIU_T2
276task ios_ras_inj::niu_sii_err_inj()
277{
278 ios_err_packet ptr_pkt;
279 bit[39:0] tpa;
280 bit[15:0] ttag;
281 VeraListIterator_ios_err_packet list_ptr;
282 SocErr_Type pkt_type;
283 integer dice;
284
285 while (1)
286 {
287 @(negedge niusii.$clk);
288 if (niusii.$req_vld === 1) niu_tagtopa[niusii.$data[79:64]] = niusii.$data[39:0];
289 if (niusii.$req_vld === 1 && !niusii_err_list.empty() && injector_on)
290 {
291 tpa = niusii.$data[39:0];
292
293 list_ptr = niusii_err_list.start();
294 ptr_pkt = list_ptr.data();
295 if (ptr_pkt!= null && ptr_pkt.rand_weight >= 0)
296 {
297 dice = urandom_range(10);
298 //printf ("IOS-RAS: try to inject random error packet dice=%d weight=%d\n", dice, ptr_pkt.rand_weight);
299 if (dice > (10 - ptr_pkt.rand_weight))
300 {
301 pkt_type = ptr_pkt.type;
302 dbg.dispmon(myname, MON_NORMAL, psprintf("niu-sii: inject random error to pkt pa=%x", tpa));
303 fork
304 {
305 vinjector(pkt_type);
306 }
307 join none
308 injected_err_list.push_back(ptr_pkt);
309 list_ptr = niusii_err_list.erase(list_ptr);
310 }
311 }
312 else
313 while (!niusii_err_list.empty() && ptr_pkt != null)
314 {
315 //printf ("IOS-RAS: try to match error pkt pa=%x with curent pa=%x\n", ptr_pkt.pa, tpa);
316 if (ptr_pkt.pa === tpa)
317 {
318 pkt_type = ptr_pkt.type;
319 //printf ("IOS-RAS: niu-sii inject error pkt pa=%x \n", tpa);
320 dbg.dispmon(myname, MON_NORMAL, psprintf("niu-sii: inject error to pkt pa=%x", tpa));
321 fork
322 {
323 vinjector(pkt_type);
324 }
325 join none
326 injected_err_list.push_back(ptr_pkt);
327 list_ptr = niusii_err_list.erase(list_ptr);
328 }
329 else
330 list_ptr.next();
331
332 if (list_ptr != null)
333 ptr_pkt = list_ptr.data();
334 }
335 }
336 }
337}
338#endif
339
340task ios_ras_inj::dmu_sii_err_inj()
341{
342 ios_err_packet ptr_pkt;
343 bit[39:0] tpa;
344 bit[15:0] tctag;
345 VeraListIterator_ios_err_packet list_ptr;
346 SocErr_Type pkt_type;
347 integer dice;
348
349 while (1)
350 {
351 @(negedge dmusii.$clk);
352 if (dmusii.$req_vld === 1 && dmusii.$data[125:122] !== 4'b0110)
353 {
354 dmu_tagtopa[dmusii.$data[79:64]] = dmusii.$data[39:0];
355 dmu_credittotag[dmusii.$data[78:75]] = dmusii.$data[79:64];
356 }
357 if (dmusii.$req_vld === 1 && !dmusii_err_list.empty() && injector_on)
358 {
359 tpa = dmusii.$data[39:0];
360 tctag = dmusii.$data[79:64];
361
362 list_ptr = dmusii_err_list.start();
363 ptr_pkt = list_ptr.data();
364
365 if (ptr_pkt!= null && ptr_pkt.rand_weight >= 0)
366 {
367 dice = urandom_range(10);
368 //printf ("IOS-RAS: try to inject random error packet dice=%d weight=%d\n", dice, ptr_pkt.rand_weight);
369 if (dice > (10 - ptr_pkt.rand_weight))
370 {
371 pkt_type = ptr_pkt.type;
372 dbg.dispmon(myname, MON_NORMAL, psprintf("dmu-sii: inject random error to pkt pa=%x", tpa));
373 fork
374 {
375 vinjector(pkt_type);
376 }
377 join none
378 ptr_pkt.ctag = tctag;
379 injected_err_list.push_back(ptr_pkt);
380 list_ptr = dmusii_err_list.erase(list_ptr);
381 }
382 }
383 else
384 while (!dmusii_err_list.empty() && ptr_pkt != null)
385 {
386 //printf ("IOS-RAS: match with err list pa=%x\n", ptr_pkt.pa);
387 if (ptr_pkt.pa === tpa)
388 {
389 pkt_type = ptr_pkt.type;
390 dbg.dispmon(myname, MON_NORMAL, psprintf("dmu-sii: inject error to pkt pa=%x", tpa));
391 fork
392 {
393 vinjector(pkt_type);
394 }
395 join none
396 ptr_pkt.ctag = tctag;
397 injected_err_list.push_back(ptr_pkt);
398 list_ptr = dmusii_err_list.erase(list_ptr);
399 }
400 else
401 list_ptr.next();
402
403 if (list_ptr != null)
404 ptr_pkt = list_ptr.data();
405 }
406 }
407 }
408}
409
410#ifndef FC_NO_NIU_T2
411task ios_ras_inj::sio_niu_err_inj()
412{
413 ios_err_packet ptr_pkt;
414 bit[15:0] tid;
415 VeraListIterator_ios_err_packet list_ptr;
416 SocErr_Type pkt_type;
417 integer dice;
418
419 while (1)
420 {
421 @(negedge sioniu.$clk);
422 if (sioniu.$req_vld === 1 && !sioniu_err_list.empty() && injector_on)
423 {
424 tid = sioniu.$data[79:64];
425
426 list_ptr = sioniu_err_list.start();
427 ptr_pkt = list_ptr.data();
428 if (ptr_pkt!= null && ptr_pkt.rand_weight >= 0)
429 {
430 dice = urandom_range(10);
431 //printf ("IOS-RAS: try to inject random error packet dice=%d weight=%d\n", dice, ptr_pkt.rand_weight);
432 if (dice > (10 - ptr_pkt.rand_weight))
433 {
434 pkt_type = ptr_pkt.type;
435 dbg.dispmon(myname, MON_NORMAL, psprintf("sio-niu: inject random error to pkt id=%x", tid));
436 fork
437 {
438 vinjector(pkt_type);
439 }
440 join none
441 injected_err_list.push_back(ptr_pkt);
442 list_ptr = sioniu_err_list.erase(list_ptr);
443 }
444 }
445 else
446 while (!sioniu_err_list.empty() && ptr_pkt != null)
447 {
448 //printf ("IOS-RAS: match with err list id=%x\n", ptr_pkt.ctag);
449 if (ptr_pkt.pa === niu_tagtopa[tid])
450 {
451 pkt_type = ptr_pkt.type;
452 fork
453 {
454 dbg.dispmon(myname, MON_NORMAL, psprintf("sio-niu: inject error to pkt ctag=%x pa=%x", tid, niu_tagtopa[tid]));
455 vinjector(pkt_type);
456 }
457 join none
458 injected_err_list.push_back(ptr_pkt);
459 list_ptr = sioniu_err_list.erase(list_ptr);
460 }
461 else
462 list_ptr.next();
463
464 if (list_ptr != null)
465 ptr_pkt = list_ptr.data();
466 }
467 }
468 }
469}
470#endif
471
472task ios_ras_inj::sio_dmu_err_inj()
473{
474 ios_err_packet ptr_pkt;
475 bit[15:0] tid;
476 VeraListIterator_ios_err_packet list_ptr;
477 SocErr_Type pkt_type;
478 integer dice;
479
480 while (1)
481 {
482 @(negedge siodmu.$clk);
483 if (siodmu.$req_vld === 1 && !siodmu_err_list.empty() && injector_on)
484 {
485 tid = siodmu.$data[79:64];
486
487 list_ptr = siodmu_err_list.start();
488 ptr_pkt = list_ptr.data();
489 if (ptr_pkt!= null && ptr_pkt.rand_weight >= 0)
490 {
491 dice = urandom_range(10);
492 //printf ("IOS-RAS: try to inject random error packet dice=%d weight=%d\n", dice, ptr_pkt.rand_weight);
493 if (dice > (10 - ptr_pkt.rand_weight))
494 {
495 pkt_type = ptr_pkt.type;
496 dbg.dispmon(myname, MON_NORMAL, psprintf("sio-dmu: inject random error to pkt id=%x", tid));
497 fork
498 {
499 vinjector(pkt_type);
500 }
501 join none
502 injected_err_list.push_back(ptr_pkt);
503 list_ptr = siodmu_err_list.erase(list_ptr);
504 }
505 }
506 else
507 while (!siodmu_err_list.empty() && ptr_pkt != null)
508 {
509 //printf ("IOS-RAS: match with err list pa=%x\n", ptr_pkt.pa);
510 if (ptr_pkt.pa === dmu_tagtopa[tid])
511 {
512 pkt_type = ptr_pkt.type;
513 fork
514 {
515 dbg.dispmon(myname, MON_NORMAL, psprintf("sio-dmu: inject error to pkt ctag=%x pa=%x", tid, dmu_tagtopa[tid]));
516 vinjector(pkt_type);
517 }
518 join none
519 injected_err_list.push_back(ptr_pkt);
520 list_ptr = siodmu_err_list.erase(list_ptr);
521 }
522 else
523 list_ptr.next();
524
525 if (list_ptr != null)
526 ptr_pkt = list_ptr.data();
527 }
528 }
529 }
530}
531
532task ios_ras_inj::l2_sio_err_inj(integer bank)
533{
534 ios_err_packet ptr_pkt;
535 bit[15:0] tid;
536 VeraListIterator_ios_err_packet list_ptr;
537 SocErr_Type pkt_type;
538 integer dice;
539
540 //printf ("%d IOS-RAS l2b%1d-sio: ready...\n",get_time(LO), bank);
541
542 while (1)
543 {
544 @(negedge l2sio[bank].$clk);
545 if (l2sio[bank].$ctag_vld === 1 && !l2sio_err_list[bank].empty() && injector_on)
546 {
547 tid = l2sio[bank].$data[15:0];
548 //printf ("IOS-RAS random: match id=%x with err list...\n", tid);
549
550 list_ptr = l2sio_err_list[bank].start();
551 ptr_pkt = list_ptr.data();
552 if (ptr_pkt!= null && ptr_pkt.rand_weight >= 0)
553 {
554 dice = urandom_range(10);
555 //printf ("IOS-RAS: try to inject random error packet dice=%d weight=%d\n", dice, ptr_pkt.rand_weight);
556 if (dice > (10 - ptr_pkt.rand_weight))
557 {
558 pkt_type = ptr_pkt.type;
559 dbg.dispmon(myname, MON_NORMAL, psprintf("l2-sio: inject random error to pkt id=%x", tid));
560 fork
561 {
562 vl2injector(pkt_type, bank);
563 }
564 join none
565 injected_err_list.push_back(ptr_pkt);
566 list_ptr = l2sio_err_list[bank].erase(list_ptr);
567 }
568 }
569 else
570 while (!l2sio_err_list[bank].empty() && ptr_pkt != null)
571 {
572 //printf ("IOS-RAS: match bus id %x with err list ctag=%x\n", tid, ptr_pkt.ctag);
573 if (ptr_pkt.ctag === tid)
574 {
575 pkt_type = ptr_pkt.type;
576 fork
577 {
578 dbg.dispmon(myname, MON_NORMAL, psprintf("l2b%1d-sio: inject error to pkt ctag=%x", bank, tid));
579 vl2injector(pkt_type, bank);
580 }
581 join none
582 injected_err_list.push_back(ptr_pkt);
583 list_ptr = l2sio_err_list[bank].erase(list_ptr);
584 }
585 else
586 list_ptr.next();
587
588 if (list_ptr != null)
589 ptr_pkt = list_ptr.data();
590 }
591 }
592 }
593}
594
595task ios_ras_inj::dmu_ncu_err_inj()
596{
597 ios_err_packet ptr_pkt;
598 bit [3:0] ttag;
599 VeraListIterator_ios_err_packet list_ptr;
600 SocErr_Type pkt_type;
601
602 while (1)
603 {
604 @(negedge dmu_ncu_inj.clk);
605 if (dmu_ncu_inj.wrack_vld === 1 && injector_on)
606 {
607 ttag = dmu_ncu_inj.wrack_tag;
608 //printf ("IOS-RAS: match id=%x with err list...\n", tid);
609
610 if (!dmuncu_wrack_err_list.empty())
611 {
612 list_ptr = dmuncu_wrack_err_list.start();
613 ptr_pkt = list_ptr.data();
614 }
615 while (!dmuncu_wrack_err_list.empty() && ptr_pkt != null)
616 {
617 //printf ("IOS-RAS: match with err list id=%x\n", ptr_pkt.ctag);
618 if (ptr_pkt.ctag == ttag)
619 {
620 pkt_type = ptr_pkt.type;
621 fork
622 {
623 dbg.dispmon(myname, MON_NORMAL, psprintf("dmu-ncu wrack: inject error to pkt ctag=%x", ttag));
624 vinjector(pkt_type);
625 }
626 join none
627 injected_err_list.push_back(ptr_pkt);
628 list_ptr = dmuncu_wrack_err_list.erase(list_ptr);
629 }
630 else
631 list_ptr.next();
632
633 if (list_ptr != null)
634 ptr_pkt = list_ptr.data();
635 }
636 }
637 }
638}
639
640task ios_ras_inj::ncu_dmu_err_inj()
641{
642 ios_err_packet ptr_pkt;
643 bit [3:0] ttag;
644 VeraListIterator_ios_err_packet list_ptr;
645 SocErr_Type pkt_type;
646
647 while (1)
648 {
649 @(negedge dmu_ncu_inj.clk);
650 if (dmu_ncu_inj.mondo_ack === 1 || dmu_ncu_inj.mondo_nack === 1 && injector_on)
651 {
652 ttag = dmu_ncu_inj.mondo_id;
653 //printf ("IOS-RAS: match id=%x with err list...\n", tid);
654
655 if (!ncudmu_mondo_err_list.empty())
656 {
657 list_ptr = ncudmu_mondo_err_list.start();
658 ptr_pkt = list_ptr.data();
659 }
660 while (!ncudmu_mondo_err_list.empty() && ptr_pkt != null)
661 {
662 //printf ("IOS-RAS: match with err list id=%x\n", ptr_pkt.ctag);
663 if (ptr_pkt.ctag == ttag)
664 {
665 pkt_type = ptr_pkt.type;
666 fork
667 {
668 dbg.dispmon(myname, MON_NORMAL, psprintf("ncu-dmu mondo: inject error to pkt tag=%x", ttag));
669 vinjector(pkt_type);
670 }
671 join none
672 injected_err_list.push_back(ptr_pkt);
673 list_ptr = ncudmu_mondo_err_list.erase(list_ptr);
674 }
675 else
676 list_ptr.next();
677
678 if (list_ptr != null)
679 ptr_pkt = list_ptr.data();
680 }
681 }
682 }
683}
684
685task ios_ras_inj::sii_dmu_err_inj()
686{
687 ios_err_packet ptr_pkt;
688 bit [3:0] ttag;
689 VeraListIterator_ios_err_packet list_ptr;
690 SocErr_Type pkt_type;
691
692 while (1)
693 {
694 @(negedge dmusii.$clk);
695 if (dmusii.$wrack_vld === 1 && injector_on)
696 {
697 ttag = dmusii.$wrack_tag;
698 //printf ("IOS-RAS: match id=%x with err list...\n", tid);
699
700 if (!siidmu_err_list.empty())
701 {
702 list_ptr = siidmu_err_list.start();
703 ptr_pkt = list_ptr.data();
704 }
705 while (!siidmu_err_list.empty() && ptr_pkt != null)
706 {
707 //printf ("IOS-RAS: match with err list id=%x\n", ptr_pkt.ctag);
708 if (ptr_pkt.pa == dmu_tagtopa[dmu_credittotag[ttag]])
709 {
710 pkt_type = ptr_pkt.type;
711 fork
712 {
713 dbg.dispmon(myname, MON_NORMAL, psprintf("sii-dmu wrack: inject error to pkt ctag=%x", ttag));
714 vinjector(pkt_type);
715 }
716 join none
717 injected_err_list.push_back(ptr_pkt);
718 list_ptr = siidmu_err_list.erase(list_ptr);
719 }
720 else
721 list_ptr.next();
722
723 if (list_ptr != null)
724 ptr_pkt = list_ptr.data();
725 }
726 }
727 }
728}
729
730task ios_ras_inj::sii_ncu_err_inj()
731{
732 ios_err_packet ptr_pkt;
733 bit[15:0] tid;
734 VeraListIterator_ios_err_packet list_ptr;
735 SocErr_Type pkt_type;
736
737 while (1)
738 {
739 @(negedge siincu.$clk);
740 if (siincu.$gnt === 1 && injector_on)
741 {
742 @(negedge siincu.$clk);
743 @(negedge siincu.$clk);
744 tid = siincu.$data[15:0];
745 //printf ("IOS-RAS: match id=%x with err list...\n", tid);
746
747 if (!siincu_err_list.empty())
748 {
749 list_ptr = siincu_err_list.start();
750 ptr_pkt = list_ptr.data();
751 }
752 while (!siincu_err_list.empty() && ptr_pkt != null)
753 {
754 //printf ("IOS-RAS: match with err list id=%x\n", ptr_pkt.ctag);
755 if (ptr_pkt.ctag === tid)
756 {
757 pkt_type = ptr_pkt.type;
758 fork
759 {
760 dbg.dispmon(myname, MON_NORMAL, psprintf("sii-ncu: inject error to pkt ctag=%x", tid));
761 vinjector(pkt_type);
762 }
763 join none
764 injected_err_list.push_back(ptr_pkt);
765 list_ptr = siincu_err_list.erase(list_ptr);
766 }
767 else
768 list_ptr.next();
769
770 if (list_ptr != null)
771 ptr_pkt = list_ptr.data();
772 }
773 }
774 }
775}
776
777task ios_ras_inj::vl2injector(SocErr_Type type, integer bank)
778{
779 bit data, data2;
780
781 case (type) {
782 L2SIO_DP:
783 {
784 @(negedge l2sio[bank].$clk);
785 data = l2sio[bank].$parity[0];
786 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to l2b%1d-sio data parity", ~data, bank));
787 SetL2SioDP0(~data, bank);
788 @(posedge l2sio[bank].$clk);
789 dbg.dispmon(myname, MON_NORMAL, psprintf("release l2b%1d-sio data parity", bank));
790 RelL2SioDP0(bank);
791 }
792 L2SIO_EBIT:
793 {
794 dbg.dispmon(myname, MON_NORMAL, psprintf("inject 1 to l2b%1d-sio ebit", bank));
795 SetL2SioEBIT(1, bank);
796 @(posedge l2sio[bank].$clk);
797 dbg.dispmon(myname, MON_NORMAL, psprintf("release l2b%1d-sio ebit", bank));
798 RelL2SioEBIT(bank);
799 }
800 L2SIO_CCE:
801 {
802 data = l2sio[bank].$data[25];
803 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to l2b%1d-sio cecc", ~data, bank));
804 SetL2SioCECC0(~data, bank);
805 @(posedge l2sio[bank].$clk);
806 dbg.dispmon(myname, MON_NORMAL, psprintf("release l2b%1d-sio cecc", bank));
807 RelL2SioCECC0(bank);
808 }
809 L2SIO_CUE:
810 {
811 data = l2sio[bank].$data[25];
812 data2 = l2sio[bank].$data[26];
813 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d %d to l2b%1d-sio cue", ~data, ~data2, bank));
814 SetL2SioCECC0(~data, bank);
815 SetL2SioCECC1(~data2, bank);
816 @(posedge l2sio[bank].$clk);
817 dbg.dispmon(myname, MON_NORMAL, psprintf("release l2b%1d-sio cue", bank));
818 RelL2SioCECC0(bank);
819 RelL2SioCECC1(bank);
820 }
821 }
822}
823
824task ios_ras_inj::vinjector(SocErr_Type type)
825{
826 bit data, data2;
827
828 case (type) {
829#ifndef FC_NO_NIU_T2
830 NIUSII_DP:
831 {
832 @(negedge niusii.$clk);
833 data = niusii.$parity[0];
834 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to niu-sii data parity", ~data));
835 SetNiuSiiDP0(~data);
836 @(posedge niusii.$clk);
837 dbg.dispmon(myname, MON_NORMAL, psprintf("release niu-sii data parity"));
838 RelNiuSiiDP0();
839 }
840#endif
841 DMUSII_DP:
842 {
843 @(negedge dmusii.$clk);
844 data = dmusii.$parity[0];
845 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to dmu-sii data parity", ~data));
846 SetDmuSiiDP0(~data);
847 @(posedge dmusii.$clk);
848 dbg.dispmon(myname, MON_NORMAL, psprintf("release dmu-sii data parity"));
849 RelDmuSiiDP0();
850 }
851 DMUSII_BEP:
852 {
853 @(negedge dmusii.$clk);
854 data = dmusii.$be_parity;
855 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to dmu-sii byte enable parity", ~data));
856 SetDmuSiiBEP(~data);
857 @(posedge dmusii.$clk);
858 dbg.dispmon(myname, MON_NORMAL, psprintf("release dmu-sii byte enable parity"));
859 RelDmuSiiBEP();
860 }
861#ifndef FC_NO_NIU_T2
862 NIUSII_AP:
863 {
864 data = niusii.$data[83];
865 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to niu-sii addr parity", ~data));
866 SetNiuSiiAP0(~data);
867 @(posedge niusii.$clk);
868 dbg.dispmon(myname, MON_NORMAL, psprintf("release niu-sii addr parity"));
869 RelNiuSiiAP0();
870 }
871#endif
872 DMUSII_AP:
873 {
874 data = dmusii.$data[83];
875 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to dmu-sii addr parity", ~data));
876 SetDmuSiiAP0(~data);
877 @(posedge dmusii.$clk);
878 dbg.dispmon(myname, MON_NORMAL, psprintf("release dmu-sii addr parity"));
879 RelDmuSiiAP0();
880 }
881#ifndef FC_NO_NIU_T2
882 NIUSII_CMDP:
883 {
884 data = niusii.$data[62];
885 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to niu-sii cmd parity", ~data));
886 SetNiuSiiCMDP(~data);
887 @(posedge niusii.$clk);
888 dbg.dispmon(myname, MON_NORMAL, psprintf("release niu-sii cmd parity"));
889 RelNiuSiiCMDP();
890 }
891#endif
892 DMUSII_CMDP:
893 {
894 data = dmusii.$data[62];
895 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to dmu-sii cmd parity", ~data));
896 SetDmuSiiCMDP(~data);
897 @(posedge dmusii.$clk);
898 dbg.dispmon(myname, MON_NORMAL, psprintf("release dmu-sii cmd parity"));
899 RelDmuSiiCMDP();
900 }
901 DMUSII_TOUT:
902 {
903 dbg.dispmon(myname, MON_NORMAL, psprintf("inject 1 to dmu-sii TOUT"));
904 SetDmuSiiTOUT();
905 @(posedge dmusii.$clk);
906 dbg.dispmon(myname, MON_NORMAL, psprintf("release dmu-sii TOUT "));
907 RelDmuSiiTOUT();
908 }
909#ifndef FC_NO_NIU_T2
910 NIUSII_IOAE:
911 {
912 dbg.dispmon(myname, MON_NORMAL, psprintf("inject 1 to niu-sii IoAE"));
913 SetNiuSiiIOAE();
914 @(posedge niusii.$clk);
915 dbg.dispmon(myname, MON_NORMAL, psprintf("release niu-sii IoAE "));
916 RelNiuSiiIOAE();
917 }
918#endif
919 DMUSII_IOAE:
920 {
921 dbg.dispmon(myname, MON_NORMAL, psprintf("inject 1 to dmu-sii IoAE"));
922 SetDmuSiiIOAE();
923 @(posedge dmusii.$clk);
924 dbg.dispmon(myname, MON_NORMAL, psprintf("release dmu-sii IoAE "));
925 RelDmuSiiIOAE();
926 }
927#ifndef FC_NO_NIU_T2
928 NIUSII_IOUE:
929 {
930 dbg.dispmon(myname, MON_NORMAL, psprintf("inject 1 to niu-sii IoUE"));
931 SetNiuSiiIOUE();
932 @(posedge niusii.$clk);
933 dbg.dispmon(myname, MON_NORMAL, psprintf("release niu-sii IoUE "));
934 RelNiuSiiIOUE();
935 }
936#endif
937 DMUSII_IOUE:
938 {
939 dbg.dispmon(myname, MON_NORMAL, psprintf("inject 1 to dmu-sii IoUE"));
940 SetDmuSiiIOUE();
941 @(posedge dmusii.$clk);
942 dbg.dispmon(myname, MON_NORMAL, psprintf("release dmu-sii IoUE "));
943 RelDmuSiiIOUE();
944 }
945#ifndef FC_NO_NIU_T2
946 NIUSII_CCE:
947 {
948 data = niusii.$data[56];
949 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to niu-sii cce", ~data));
950 SetNiuSiiCECC0(~data);
951 @(posedge niusii.$clk);
952 dbg.dispmon(myname, MON_NORMAL, psprintf("release niu-sii cce "));
953 RelNiuSiiCECC0();
954 }
955#endif
956 DMUSII_CCE:
957 {
958 data = dmusii.$data[56];
959 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to dmu-sii cce", ~data));
960 SetDmuSiiCECC0(~data);
961 @(posedge dmusii.$clk);
962 dbg.dispmon(myname, MON_NORMAL, psprintf("release dmu-sii cce "));
963 RelDmuSiiCECC0();
964 }
965#ifndef FC_NO_NIU_T2
966 NIUSII_CUE:
967 {
968 data = niusii.$data[56];
969 data2 = niusii.$data[57];
970 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d %d to niu-sii cue", ~data, ~data2));
971 SetNiuSiiCECC0(~data);
972 SetNiuSiiCECC1(~data2);
973 @(posedge niusii.$clk);
974 dbg.dispmon(myname, MON_NORMAL, psprintf("release niu-sii cue"));
975 RelNiuSiiCECC0();
976 RelNiuSiiCECC1();
977 }
978#endif
979 DMUSII_CUE:
980 {
981 data = dmusii.$data[56];
982 data2 = dmusii.$data[57];
983 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d %d to dmu-sii cue", ~data, ~data2));
984 SetDmuSiiCECC0(~data);
985 SetDmuSiiCECC1(~data2);
986 @(posedge dmusii.$clk);
987 dbg.dispmon(myname, MON_NORMAL, psprintf("release dmu-sii cue"));
988 RelDmuSiiCECC0();
989 RelDmuSiiCECC1();
990 }
991#ifndef FC_NO_NIU_T2
992 SIONIU_DP:
993 {
994 @(negedge sioniu.$clk);
995 data = sioniu.$parity[0];
996 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to sio-niu data parity", ~data));
997 SetSioNiuDP0(~data);
998 @(posedge sioniu.$clk);
999 dbg.dispmon(myname, MON_NORMAL, psprintf("release sio-niu data parity"));
1000 RelSioNiuDP0();
1001 }
1002#endif
1003 SIODMU_DP:
1004 {
1005 @(negedge siodmu.$clk);
1006 data = siodmu.$parity[0];
1007 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to sio-dmu data parity", ~data));
1008 SetSioDmuDP0(~data);
1009 @(posedge siodmu.$clk);
1010 dbg.dispmon(myname, MON_NORMAL, psprintf("release sio-dmu data parity"));
1011 RelSioDmuDP0();
1012 }
1013#ifndef FC_NO_NIU_T2
1014 SIONIU_CCE:
1015 {
1016 data = sioniu.$data[56];
1017 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to sio-niu cce", ~data));
1018 SetSioNiuCECC0(~data);
1019 @(posedge sioniu.$clk);
1020 dbg.dispmon(myname, MON_NORMAL, psprintf("release sio-niu cce"));
1021 RelSioNiuCECC0();
1022 }
1023#endif
1024 SIODMU_CCE:
1025 {
1026 data = siodmu.$data[56];
1027 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to sio-dmu cce", ~data));
1028 SetSioDmuCECC0(~data);
1029 @(posedge siodmu.$clk);
1030 dbg.dispmon(myname, MON_NORMAL, psprintf("release sio-dmu cce"));
1031 RelSioDmuCECC0();
1032 }
1033#ifndef FC_NO_NIU_T2
1034 SIONIU_CUE:
1035 {
1036 data = sioniu.$data[56];
1037 data2 = sioniu.$data[57];
1038 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d %d to sio-niu cue", ~data, ~data2));
1039 SetSioNiuCECC0(~data);
1040 SetSioNiuCECC1(~data2);
1041 @(posedge sioniu.$clk);
1042 dbg.dispmon(myname, MON_NORMAL, psprintf("release sio-niu cue"));
1043 RelSioNiuCECC0();
1044 RelSioNiuCECC1();
1045 }
1046#endif
1047 SIODMU_CUE:
1048 {
1049 data = siodmu.$data[56];
1050 data2 = siodmu.$data[57];
1051 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d %d to sio-dmu cue", ~data, ~data2));
1052 SetSioDmuCECC0(~data);
1053 SetSioDmuCECC1(~data2);
1054 @(posedge siodmu.$clk);
1055 dbg.dispmon(myname, MON_NORMAL, psprintf("release sio-dmu cue"));
1056 RelSioDmuCECC0();
1057 RelSioDmuCECC1();
1058 }
1059 SIINCU_DP:
1060 {
1061 @(negedge siincu.$clk);
1062 data = siincu.$parity[0];
1063 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to sii-ncu data parity", ~data));
1064 SetSiiNcuDP0(~data);
1065 @(posedge siincu.$clk);
1066 dbg.dispmon(myname, MON_NORMAL, psprintf("release sii-ncu data parity"));
1067 RelSiiNcuDP0();
1068 }
1069 SIINCU_CCE:
1070 {
1071 data = siincu.$data[16];
1072 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to sii-ncu cce", ~data));
1073 SetSiiNcuCECC0(~data);
1074 @(posedge siincu.$clk);
1075 dbg.dispmon(myname, MON_NORMAL, psprintf("release sii-ncu cce parity"));
1076 RelSiiNcuCECC0();
1077 }
1078 SIINCU_CUE:
1079 {
1080 data = siincu.$data[16];
1081 data2 = siincu.$data[17];
1082 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d %d to sii-ncu cue", ~data, ~data2));
1083 SetSiiNcuCECC0(~data);
1084 SetSiiNcuCECC1(~data2);
1085 @(posedge siincu.$clk);
1086 dbg.dispmon(myname, MON_NORMAL, psprintf("release sii-ncu cue"));
1087 RelSiiNcuCECC0();
1088 RelSiiNcuCECC1();
1089 }
1090 DMUNCU_WRACK_P:
1091 {
1092 data = dmu_ncu_inj.wrack_par;
1093 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to dmu-ncu wrack", ~data));
1094 SetDmuNcuWRACKPAR(~data);
1095 @(posedge dmu_ncu_inj.clk);
1096 dbg.dispmon(myname, MON_NORMAL, psprintf("release dmu-ncu wrack"));
1097 RelDmuNcuWRACKPAR();
1098 }
1099 NCUDMU_MONDO_IDP:
1100 {
1101 data = dmu_ncu_inj.mondo_id_par;
1102 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to dmu-ncu mondo id par", ~data));
1103 SetNcuDmuMONDOPAR(~data);
1104 @(posedge dmu_ncu_inj.clk);
1105 dbg.dispmon(myname, MON_NORMAL, psprintf("release dmu-ncu mondo id par"));
1106 RelNcuDmuMONDOPAR();
1107 }
1108 SIIDMU_WRACK_P:
1109 {
1110 data = dmusii.$wrack_par;
1111 dbg.dispmon(myname, MON_NORMAL, psprintf("inject %d to sii-dmu wrack", ~data));
1112 SetSiiDmuWRACKPAR(~data);
1113 @(posedge dmusii.$clk);
1114 dbg.dispmon(myname, MON_NORMAL, psprintf("release sii-dmu wrack"));
1115 RelSiiDmuWRACKPAR();
1116 }
1117 }
1118}
Full OpenSPARC design & verification tarball including full HDL.