Initial commit of OpenSPARC T2 design and verification files.

[OpenSPARC-T2-DV] / verif / env / common / verilog / misc / l2_scrub.v

// ========== Copyright Header Begin ==========================================
// 
// OpenSPARC T2 Processor File: l2_scrub.v
// Copyright (C) 1995-2007 Sun Microsystems, Inc. All Rights Reserved
// 4150 Network Circle, Santa Clara, California 95054, U.S.A.
//
// * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; version 2 of the License.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
// 
// For the avoidance of doubt, and except that if any non-GPL license 
// choice is available it will apply instead, Sun elects to use only 
// the General Public License version 2 (GPLv2) at this time for any 
// software where a choice of GPL license versions is made 
// available with the language indicating that GPLv2 or any later version 
// may be used, or where a choice of which version of the GPL is applied is 
// otherwise unspecified. 
//
// Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, 
// CA 95054 USA or visit www.sun.com if you need additional information or 
// have any questions. 
// 
// ========== Copyright Header End ============================================
module l2_scrub;

`ifndef GATESIM
`ifndef NOL2RTL
`ifndef AXIS
`ifndef AXIS_TL


reg [31:0] scrub_freq;
integer    indexType;
reg [16*8:0] fcModesTempstr;
reg [8:0] bank_index;
reg [31:0] localSeed;

integer scrub_count0;
integer scrub_count1;
integer scrub_count2;
integer scrub_count3;
integer scrub_count4;
integer scrub_count5;
integer scrub_count6;
integer scrub_count7;

initial begin
 #10;
 while (scrub_freq) begin
 @(scrub_count0 or
    scrub_count1 or
    scrub_count2 or
    scrub_count3 or
    scrub_count4 or
    scrub_count5 or
    scrub_count6 or
    scrub_count7);
   `PR_ALWAYS ("l2_scrub", `ALWAYS,"L2_SCRUB, scrubs done b0-b7 =%d,%d,%d,%d,%d,%d,%d,%d", scrub_count0,scrub_count1,scrub_count2,scrub_count3,scrub_count4,scrub_count5,scrub_count6,scrub_count7);
 end
end


 initial begin
   #10;
   if (scrub_freq) begin
     @(`TOP.sim_status);
     `PR_ALWAYS ("l2_scrub", `ALWAYS,"L2_SCRUB, final scrubs done b0-b7 = %d,%d,%d,%d,%d,%d,%d,%d", scrub_count0,scrub_count1,scrub_count2,scrub_count3,scrub_count4,scrub_count5,scrub_count6,scrub_count7);
   end
 end


 initial begin

   scrub_freq = 0;
   bank_index = 0;
   indexType = 0;
   scrub_count0 = 0;
   scrub_count1 = 0;
   scrub_count2 = 0;
   scrub_count3 = 0;
   scrub_count4 = 0;
   scrub_count5 = 0;
   scrub_count6 = 0;
   scrub_count7 = 0;
   
   // if L2_SCRUB, use default freq. If L2_SCRUB_FREQ, use given freq,
   // else do nothing.
   if ($test$plusargs("L2_SCRUB") || 
       $value$plusargs("L2_SCRUB_FREQ=%d",scrub_freq)) begin
     // default of every 2200 clks. scrubs take about 1800 clocks!
     // don't want > 50% of time spent in scrubs!
     if (scrub_freq == 0) scrub_freq = 2200;
     if (scrub_freq < 1000) begin
       scrub_freq = 1000;
       `PR_ALWAYS ("l2_scrub", `ALWAYS,"L2_SCRUB_FREQ min is 1000");
     end

     `PR_ALWAYS ("l2_scrub", `ALWAYS,"L2_SCRUB_FREQ is set to %d (min=1000)", scrub_freq);

     // index choices:
     // 0) leave alone. do not use -> L2_SCRUB_IDX
     // 1) random idx always picked  +L2_SCRUB_IDX=rand
     // 2) increment from x          +L2_SCRUB_IDX=n
     if ($test$plusargs("L2_SCRUB_IDX")) begin
       if ($value$plusargs("L2_SCRUB_IDX=%s", fcModesTempstr)) begin
         if (fcModesTempstr == "rand" || fcModesTempstr == "random") indexType = 1;
         else if ($value$plusargs("L2_SCRUB_IDX=%h", bank_index)) indexType = 2;
       end
     end

     if (indexType == 0) `PR_ALWAYS ("l2_scrub", `ALWAYS,"L2_SCRUB_IDX will be left alone");
     if (indexType == 1) `PR_ALWAYS ("l2_scrub", `ALWAYS,"L2_SCRUB_IDX will be random");
     if (indexType == 2) `PR_ALWAYS ("l2_scrub", `ALWAYS,"L2_SCRUB_IDX will increment from %h", bank_index);


     // wait...
     #10;

     // get the original seed and use it locally so others
     // are not affected by this "somtimes used" code.
     localSeed = `PARGS.seedin;

     // wait for a thread to be unparked
     @(negedge `TOP.in_reset);

     // wait for any one thread to be out of boot.
     @(`TOP.gOutOfBoot);

     // increase timeouts since scrubbing is slow
     `PARGS.timeout = `PARGS.timeout * 4;
     `PR_ALWAYS ("l2_scrub", `ALWAYS,"L2_SCRUB `PARGS.timeout increased to %d",`PARGS.timeout);
     `PARGS.th_timeout = `PARGS.timeout * 5;
     `PR_ALWAYS ("l2_scrub", `ALWAYS,"L2_SCRUB `PARGS.th_timeout increased to %d",`PARGS.th_timeout);

     repeat (100) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

     fork
       scrubBank0(bank_index);
       scrubBank1(bank_index);
       scrubBank2(bank_index);
       scrubBank3(bank_index);
       scrubBank4(bank_index);
       scrubBank5(bank_index);
       scrubBank6(bank_index);
       scrubBank7(bank_index);
     join
   end // if
 end // initial
 

 // 1) force the counter to a high value for 2 clocks,
 //    force the scrub index to a random value.
 // 2) release the forces.
 // 3) wait for the scrub (posedge csr_filbuf_scrub_ready).
 // 4) wait for scrub to be done (posedge filbuf.fb_tecc_pend_reset)
 // 5) repeat
 task scrubBank0;
   input l2_bank_index;

   reg [8:0] l2_bank_index;
   reg [12:0] rtl_idx;
   reg [11:0] randVal;
   reg [31:0] value;
   
   begin


$strobe("1 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",0,`PARGS.seed,localSeed);


     if (`TOP.cpu.ncu_l2t_pm == 0 || 
         (`TOP.cpu.ncu_l2t_pm == 1 && `TOP.cpu.ncu_l2t_ba01 == 1)) begin
       // initial skew between banks
       repeat ($random(localSeed)%16) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

       if (indexType == 2) begin
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d starting index = %h", 0, l2_bank_index);
         force `TOP.cpu.l2t0.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
         force `TOP.cpu.l2t0.arbadr.arb_data_ecc_idx_en = 1;
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         release `TOP.cpu.l2t0.arbadr.arbadr_data_ecc_idx_plus1;
         release `TOP.cpu.l2t0.arbadr.arb_data_ecc_idx_en;
       end

       while (1) begin

$strobe("2 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",0,`PARGS.seed,localSeed);

         // set counter to be valueIn clocks away from matching
         // {csr_l2_control_reg[14:3], 20'b0}.
         // Pick csr_l2_control_reg[14:3] at random then subtract
         // valueIn. Force this new value into the scrub_counter so
         // it will count up naturally and then match.
         randVal = $random(localSeed);
         if (randVal == 12'hfff) randVal = 12'hffe;
         if (randVal == 0) randVal = 1;
         value = {randVal,20'h0} - scrub_freq;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d scrub_counter = %d", 0,value);
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d csr_l2_control_reg[14:3] = %d", 0, randVal);
         force `TOP.cpu.l2t0.csr.scrub_counter = value;
         force `TOP.cpu.l2t0.csr.csr_l2_control_reg[14:3] = randVal;
         force `TOP.cpu.l2t0.csr.csr_l2_control_reg[2] = 1;

         if (indexType == 1) begin
           l2_bank_index = $random(localSeed);
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d index = %h", 0, l2_bank_index);
           // force `TOP.cpu.l2t0.csr.arbadr_data_ecc_idx = l2_bank_index;
           force `TOP.cpu.l2t0.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
           force `TOP.cpu.l2t0.arbadr.arb_data_ecc_idx_en = 1;
         end

         else begin
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB RTL bank %d index = %h", 0, `TOP.cpu.l2t0.csr.arbadr_data_ecc_idx);
         end

         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

         // 2 release the forces.
         release `TOP.cpu.l2t0.csr.scrub_counter;
         release `TOP.cpu.l2t0.csr.csr_l2_control_reg[14:3];
         // if (indexType == 1) release `TOP.cpu.l2t0.csr.arbadr_data_ecc_idx;
         if (indexType == 1) release `TOP.cpu.l2t0.arbadr.arbadr_data_ecc_idx_plus1;
         if (indexType == 1) release `TOP.cpu.l2t0.arbadr.arb_data_ecc_idx_en;

         // 3 wait for the scrub to be signaled (posedge csr_filbuf_scrub_ready).
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on csr_filbuf_scrub_ready (scrub counter matching)", 0);
         @(posedge `TOP.cpu.l2t0.csr.csr_filbuf_scrub_ready);
         rtl_idx = `TOP.cpu.l2t0.csr.scrub_addr;

         // 3 wait for scrub to start
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en assert (wait for scrub to start)", 0);                               
         @(posedge `TOP.cpu.l2t0.tagctl.scrub_fsm_en);

         // 4 wait for scrub to be done (all ways)
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en de-assert(scrub has started, wait for finish)", 0);                              
         @(negedge `TOP.cpu.l2t0.tagctl.scrub_fsm_en);
         scrub_count0 = scrub_count0+1;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d scrub has finished (count=%d)", 0,scrub_count0);

         // check index incrementing
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         if (rtl_idx == `TOP.cpu.l2t0.csr.scrub_addr)
           `PR_ERROR ("l2_scrub", `ERROR, "ERROR: bank 0 RTL did not increment the scrub index!");

       end // 5 while 1
     end
   end
 endtask


 // 1) force the counter to a high value for 2 clocks,
 //    force the scrub index to a random value.
 // 2) release the forces.
 // 3) wait for the scrub (posedge csr_filbuf_scrub_ready).
 // 4) wait for scrub to be done (posedge filbuf.fb_tecc_pend_reset)
 // 5) repeat
 task scrubBank1;
   input l2_bank_index;

   reg [8:0] l2_bank_index;
   reg [12:0] rtl_idx;
   reg [11:0] randVal;
   reg [31:0] value;
   
   begin


$strobe("1 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",1,`PARGS.seed,localSeed);


     if (`TOP.cpu.ncu_l2t_pm == 0 || 
         (`TOP.cpu.ncu_l2t_pm == 1 && `TOP.cpu.ncu_l2t_ba01 == 1)) begin
       // initial skew between banks
       repeat ($random(localSeed)%16) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

       if (indexType == 2) begin
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d starting index = %h", 1, l2_bank_index);
         force `TOP.cpu.l2t1.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
         force `TOP.cpu.l2t1.arbadr.arb_data_ecc_idx_en = 1;
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         release `TOP.cpu.l2t1.arbadr.arbadr_data_ecc_idx_plus1;
         release `TOP.cpu.l2t1.arbadr.arb_data_ecc_idx_en;
       end

       while (1) begin

$strobe("2 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",1,`PARGS.seed,localSeed);

         // set counter to be valueIn clocks away from matching
         // {csr_l2_control_reg[14:3], 20'b0}.
         // Pick csr_l2_control_reg[14:3] at random then subtract
         // valueIn. Force this new value into the scrub_counter so
         // it will count up naturally and then match.
         randVal = $random(localSeed);
         if (randVal == 12'hfff) randVal = 12'hffe;
         if (randVal == 0) randVal = 1;
         value = {randVal,20'h0} - scrub_freq;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d scrub_counter = %d", 1,value);
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d csr_l2_control_reg[14:3] = %d", 1, randVal);
         force `TOP.cpu.l2t1.csr.scrub_counter = value;
         force `TOP.cpu.l2t1.csr.csr_l2_control_reg[14:3] = randVal;
         force `TOP.cpu.l2t1.csr.csr_l2_control_reg[2] = 1;

         if (indexType == 1) begin
           l2_bank_index = $random(localSeed);
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d index = %h", 1, l2_bank_index);
           // force `TOP.cpu.l2t1.csr.arbadr_data_ecc_idx = l2_bank_index;
           force `TOP.cpu.l2t1.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
           force `TOP.cpu.l2t1.arbadr.arb_data_ecc_idx_en = 1;
         end

         else begin
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB RTL bank %d index = %h", 1, `TOP.cpu.l2t1.csr.arbadr_data_ecc_idx);
         end

         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

         // 2 release the forces.
         release `TOP.cpu.l2t1.csr.scrub_counter;
         release `TOP.cpu.l2t1.csr.csr_l2_control_reg[14:3];
         // if (indexType == 1) release `TOP.cpu.l2t1.csr.arbadr_data_ecc_idx;
         if (indexType == 1) release `TOP.cpu.l2t1.arbadr.arbadr_data_ecc_idx_plus1;
         if (indexType == 1) release `TOP.cpu.l2t1.arbadr.arb_data_ecc_idx_en;

         // 3 wait for the scrub to be signaled (posedge csr_filbuf_scrub_ready).
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on csr_filbuf_scrub_ready (scrub counter matching)", 1);
         @(posedge `TOP.cpu.l2t1.csr.csr_filbuf_scrub_ready);
         rtl_idx = `TOP.cpu.l2t1.csr.scrub_addr;

         // 3 wait for scrub to start
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en assert (wait for scrub to start)", 1);                               
         @(posedge `TOP.cpu.l2t1.tagctl.scrub_fsm_en);

         // 4 wait for scrub to be done (all ways)
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en de-assert(scrub has started, wait for finish)", 1);                              
         @(negedge `TOP.cpu.l2t1.tagctl.scrub_fsm_en);
         scrub_count1 = scrub_count1+1;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d scrub has finished (count=%d)", 1,scrub_count1);

         // check index incrementing
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         if (rtl_idx == `TOP.cpu.l2t1.csr.scrub_addr)
           `PR_ERROR ("l2_scrub", `ERROR, "ERROR: bank 1 RTL did not increment the scrub index!");

       end // 5 while 1
     end
   end
 endtask


 // 1) force the counter to a high value for 2 clocks,
 //    force the scrub index to a random value.
 // 2) release the forces.
 // 3) wait for the scrub (posedge csr_filbuf_scrub_ready).
 // 4) wait for scrub to be done (posedge filbuf.fb_tecc_pend_reset)
 // 5) repeat
 task scrubBank2;
   input l2_bank_index;

   reg [8:0] l2_bank_index;
   reg [12:0] rtl_idx;
   reg [11:0] randVal;
   reg [31:0] value;
   
   begin


$strobe("1 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",2,`PARGS.seed,localSeed);


     if (`TOP.cpu.ncu_l2t_pm == 0 || 
         (`TOP.cpu.ncu_l2t_pm == 1 && `TOP.cpu.ncu_l2t_ba23 == 1)) begin
       // initial skew between banks
       repeat ($random(localSeed)%16) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

       if (indexType == 2) begin
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d starting index = %h", 2, l2_bank_index);
         force `TOP.cpu.l2t2.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
         force `TOP.cpu.l2t2.arbadr.arb_data_ecc_idx_en = 1;
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         release `TOP.cpu.l2t2.arbadr.arbadr_data_ecc_idx_plus1;
         release `TOP.cpu.l2t2.arbadr.arb_data_ecc_idx_en;
       end

       while (1) begin

$strobe("2 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",2,`PARGS.seed,localSeed);

         // set counter to be valueIn clocks away from matching
         // {csr_l2_control_reg[14:3], 20'b0}.
         // Pick csr_l2_control_reg[14:3] at random then subtract
         // valueIn. Force this new value into the scrub_counter so
         // it will count up naturally and then match.
         randVal = $random(localSeed);
         if (randVal == 12'hfff) randVal = 12'hffe;
         if (randVal == 0) randVal = 1;
         value = {randVal,20'h0} - scrub_freq;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d scrub_counter = %d", 2,value);
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d csr_l2_control_reg[14:3] = %d", 2, randVal);
         force `TOP.cpu.l2t2.csr.scrub_counter = value;
         force `TOP.cpu.l2t2.csr.csr_l2_control_reg[14:3] = randVal;
         force `TOP.cpu.l2t2.csr.csr_l2_control_reg[2] = 1;

         if (indexType == 1) begin
           l2_bank_index = $random(localSeed);
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d index = %h", 2, l2_bank_index);
           // force `TOP.cpu.l2t2.csr.arbadr_data_ecc_idx = l2_bank_index;
           force `TOP.cpu.l2t2.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
           force `TOP.cpu.l2t2.arbadr.arb_data_ecc_idx_en = 1;
         end

         else begin
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB RTL bank %d index = %h", 2, `TOP.cpu.l2t2.csr.arbadr_data_ecc_idx);
         end

         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

         // 2 release the forces.
         release `TOP.cpu.l2t2.csr.scrub_counter;
         release `TOP.cpu.l2t2.csr.csr_l2_control_reg[14:3];
         // if (indexType == 1) release `TOP.cpu.l2t2.csr.arbadr_data_ecc_idx;
         if (indexType == 1) release `TOP.cpu.l2t2.arbadr.arbadr_data_ecc_idx_plus1;
         if (indexType == 1) release `TOP.cpu.l2t2.arbadr.arb_data_ecc_idx_en;

         // 3 wait for the scrub to be signaled (posedge csr_filbuf_scrub_ready).
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on csr_filbuf_scrub_ready (scrub counter matching)", 2);
         @(posedge `TOP.cpu.l2t2.csr.csr_filbuf_scrub_ready);
         rtl_idx = `TOP.cpu.l2t2.csr.scrub_addr;

         // 3 wait for scrub to start
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en assert (wait for scrub to start)", 2);                               
         @(posedge `TOP.cpu.l2t2.tagctl.scrub_fsm_en);

         // 4 wait for scrub to be done (all ways)
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en de-assert(scrub has started, wait for finish)", 2);                              
         @(negedge `TOP.cpu.l2t2.tagctl.scrub_fsm_en);
         scrub_count2 = scrub_count2+1;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d scrub has finished (count=%d)", 2,scrub_count2);

         // check index incrementing
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         if (rtl_idx == `TOP.cpu.l2t2.csr.scrub_addr)
           `PR_ERROR ("l2_scrub", `ERROR, "ERROR: bank 2 RTL did not increment the scrub index!");

       end // 5 while 1
     end
   end
 endtask


 // 1) force the counter to a high value for 2 clocks,
 //    force the scrub index to a random value.
 // 2) release the forces.
 // 3) wait for the scrub (posedge csr_filbuf_scrub_ready).
 // 4) wait for scrub to be done (posedge filbuf.fb_tecc_pend_reset)
 // 5) repeat
 task scrubBank3;
   input l2_bank_index;

   reg [8:0] l2_bank_index;
   reg [12:0] rtl_idx;
   reg [11:0] randVal;
   reg [31:0] value;
   
   begin


$strobe("1 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",3,`PARGS.seed,localSeed);


     if (`TOP.cpu.ncu_l2t_pm == 0 || 
         (`TOP.cpu.ncu_l2t_pm == 1 && `TOP.cpu.ncu_l2t_ba23 == 1)) begin
       // initial skew between banks
       repeat ($random(localSeed)%16) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

       if (indexType == 2) begin
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d starting index = %h", 3, l2_bank_index);
         force `TOP.cpu.l2t3.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
         force `TOP.cpu.l2t3.arbadr.arb_data_ecc_idx_en = 1;
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         release `TOP.cpu.l2t3.arbadr.arbadr_data_ecc_idx_plus1;
         release `TOP.cpu.l2t3.arbadr.arb_data_ecc_idx_en;
       end

       while (1) begin

$strobe("2 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",3,`PARGS.seed,localSeed);

         // set counter to be valueIn clocks away from matching
         // {csr_l2_control_reg[14:3], 20'b0}.
         // Pick csr_l2_control_reg[14:3] at random then subtract
         // valueIn. Force this new value into the scrub_counter so
         // it will count up naturally and then match.
         randVal = $random(localSeed);
         if (randVal == 12'hfff) randVal = 12'hffe;
         if (randVal == 0) randVal = 1;
         value = {randVal,20'h0} - scrub_freq;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d scrub_counter = %d", 3,value);
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d csr_l2_control_reg[14:3] = %d", 3, randVal);
         force `TOP.cpu.l2t3.csr.scrub_counter = value;
         force `TOP.cpu.l2t3.csr.csr_l2_control_reg[14:3] = randVal;
         force `TOP.cpu.l2t3.csr.csr_l2_control_reg[2] = 1;

         if (indexType == 1) begin
           l2_bank_index = $random(localSeed);
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d index = %h", 3, l2_bank_index);
           // force `TOP.cpu.l2t3.csr.arbadr_data_ecc_idx = l2_bank_index;
           force `TOP.cpu.l2t3.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
           force `TOP.cpu.l2t3.arbadr.arb_data_ecc_idx_en = 1;
         end

         else begin
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB RTL bank %d index = %h", 3, `TOP.cpu.l2t3.csr.arbadr_data_ecc_idx);
         end

         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

         // 2 release the forces.
         release `TOP.cpu.l2t3.csr.scrub_counter;
         release `TOP.cpu.l2t3.csr.csr_l2_control_reg[14:3];
         // if (indexType == 1) release `TOP.cpu.l2t3.csr.arbadr_data_ecc_idx;
         if (indexType == 1) release `TOP.cpu.l2t3.arbadr.arbadr_data_ecc_idx_plus1;
         if (indexType == 1) release `TOP.cpu.l2t3.arbadr.arb_data_ecc_idx_en;

         // 3 wait for the scrub to be signaled (posedge csr_filbuf_scrub_ready).
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on csr_filbuf_scrub_ready (scrub counter matching)", 3);
         @(posedge `TOP.cpu.l2t3.csr.csr_filbuf_scrub_ready);
         rtl_idx = `TOP.cpu.l2t3.csr.scrub_addr;

         // 3 wait for scrub to start
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en assert (wait for scrub to start)", 3);                               
         @(posedge `TOP.cpu.l2t3.tagctl.scrub_fsm_en);

         // 4 wait for scrub to be done (all ways)
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en de-assert(scrub has started, wait for finish)", 3);                              
         @(negedge `TOP.cpu.l2t3.tagctl.scrub_fsm_en);
         scrub_count3 = scrub_count3+1;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d scrub has finished (count=%d)", 3,scrub_count3);

         // check index incrementing
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         if (rtl_idx == `TOP.cpu.l2t3.csr.scrub_addr)
           `PR_ERROR ("l2_scrub", `ERROR, "ERROR: bank 3 RTL did not increment the scrub index!");

       end // 5 while 1
     end
   end
 endtask


 // 1) force the counter to a high value for 2 clocks,
 //    force the scrub index to a random value.
 // 2) release the forces.
 // 3) wait for the scrub (posedge csr_filbuf_scrub_ready).
 // 4) wait for scrub to be done (posedge filbuf.fb_tecc_pend_reset)
 // 5) repeat
 task scrubBank4;
   input l2_bank_index;

   reg [8:0] l2_bank_index;
   reg [12:0] rtl_idx;
   reg [11:0] randVal;
   reg [31:0] value;
   
   begin


$strobe("1 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",4,`PARGS.seed,localSeed);


     if (`TOP.cpu.ncu_l2t_pm == 0 || 
         (`TOP.cpu.ncu_l2t_pm == 1 && `TOP.cpu.ncu_l2t_ba45 == 1)) begin
       // initial skew between banks
       repeat ($random(localSeed)%16) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

       if (indexType == 2) begin
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d starting index = %h", 4, l2_bank_index);
         force `TOP.cpu.l2t4.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
         force `TOP.cpu.l2t4.arbadr.arb_data_ecc_idx_en = 1;
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         release `TOP.cpu.l2t4.arbadr.arbadr_data_ecc_idx_plus1;
         release `TOP.cpu.l2t4.arbadr.arb_data_ecc_idx_en;
       end

       while (1) begin

$strobe("2 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",4,`PARGS.seed,localSeed);

         // set counter to be valueIn clocks away from matching
         // {csr_l2_control_reg[14:3], 20'b0}.
         // Pick csr_l2_control_reg[14:3] at random then subtract
         // valueIn. Force this new value into the scrub_counter so
         // it will count up naturally and then match.
         randVal = $random(localSeed);
         if (randVal == 12'hfff) randVal = 12'hffe;
         if (randVal == 0) randVal = 1;
         value = {randVal,20'h0} - scrub_freq;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d scrub_counter = %d", 4,value);
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d csr_l2_control_reg[14:3] = %d", 4, randVal);
         force `TOP.cpu.l2t4.csr.scrub_counter = value;
         force `TOP.cpu.l2t4.csr.csr_l2_control_reg[14:3] = randVal;
         force `TOP.cpu.l2t4.csr.csr_l2_control_reg[2] = 1;

         if (indexType == 1) begin
           l2_bank_index = $random(localSeed);
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d index = %h", 4, l2_bank_index);
           // force `TOP.cpu.l2t4.csr.arbadr_data_ecc_idx = l2_bank_index;
           force `TOP.cpu.l2t4.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
           force `TOP.cpu.l2t4.arbadr.arb_data_ecc_idx_en = 1;
         end

         else begin
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB RTL bank %d index = %h", 4, `TOP.cpu.l2t4.csr.arbadr_data_ecc_idx);
         end

         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

         // 2 release the forces.
         release `TOP.cpu.l2t4.csr.scrub_counter;
         release `TOP.cpu.l2t4.csr.csr_l2_control_reg[14:3];
         // if (indexType == 1) release `TOP.cpu.l2t4.csr.arbadr_data_ecc_idx;
         if (indexType == 1) release `TOP.cpu.l2t4.arbadr.arbadr_data_ecc_idx_plus1;
         if (indexType == 1) release `TOP.cpu.l2t4.arbadr.arb_data_ecc_idx_en;

         // 3 wait for the scrub to be signaled (posedge csr_filbuf_scrub_ready).
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on csr_filbuf_scrub_ready (scrub counter matching)", 4);
         @(posedge `TOP.cpu.l2t4.csr.csr_filbuf_scrub_ready);
         rtl_idx = `TOP.cpu.l2t4.csr.scrub_addr;

         // 3 wait for scrub to start
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en assert (wait for scrub to start)", 4);                               
         @(posedge `TOP.cpu.l2t4.tagctl.scrub_fsm_en);

         // 4 wait for scrub to be done (all ways)
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en de-assert(scrub has started, wait for finish)", 4);                              
         @(negedge `TOP.cpu.l2t4.tagctl.scrub_fsm_en);
         scrub_count4 = scrub_count4+1;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d scrub has finished (count=%d)", 4,scrub_count4);

         // check index incrementing
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         if (rtl_idx == `TOP.cpu.l2t4.csr.scrub_addr)
           `PR_ERROR ("l2_scrub", `ERROR, "ERROR: bank 4 RTL did not increment the scrub index!");

       end // 5 while 1
     end
   end
 endtask


 // 1) force the counter to a high value for 2 clocks,
 //    force the scrub index to a random value.
 // 2) release the forces.
 // 3) wait for the scrub (posedge csr_filbuf_scrub_ready).
 // 4) wait for scrub to be done (posedge filbuf.fb_tecc_pend_reset)
 // 5) repeat
 task scrubBank5;
   input l2_bank_index;

   reg [8:0] l2_bank_index;
   reg [12:0] rtl_idx;
   reg [11:0] randVal;
   reg [31:0] value;
   
   begin


$strobe("1 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",5,`PARGS.seed,localSeed);


     if (`TOP.cpu.ncu_l2t_pm == 0 || 
         (`TOP.cpu.ncu_l2t_pm == 1 && `TOP.cpu.ncu_l2t_ba45 == 1)) begin
       // initial skew between banks
       repeat ($random(localSeed)%16) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

       if (indexType == 2) begin
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d starting index = %h", 5, l2_bank_index);
         force `TOP.cpu.l2t5.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
         force `TOP.cpu.l2t5.arbadr.arb_data_ecc_idx_en = 1;
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         release `TOP.cpu.l2t5.arbadr.arbadr_data_ecc_idx_plus1;
         release `TOP.cpu.l2t5.arbadr.arb_data_ecc_idx_en;
       end

       while (1) begin

$strobe("2 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",5,`PARGS.seed,localSeed);

         // set counter to be valueIn clocks away from matching
         // {csr_l2_control_reg[14:3], 20'b0}.
         // Pick csr_l2_control_reg[14:3] at random then subtract
         // valueIn. Force this new value into the scrub_counter so
         // it will count up naturally and then match.
         randVal = $random(localSeed);
         if (randVal == 12'hfff) randVal = 12'hffe;
         if (randVal == 0) randVal = 1;
         value = {randVal,20'h0} - scrub_freq;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d scrub_counter = %d", 5,value);
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d csr_l2_control_reg[14:3] = %d", 5, randVal);
         force `TOP.cpu.l2t5.csr.scrub_counter = value;
         force `TOP.cpu.l2t5.csr.csr_l2_control_reg[14:3] = randVal;
         force `TOP.cpu.l2t5.csr.csr_l2_control_reg[2] = 1;

         if (indexType == 1) begin
           l2_bank_index = $random(localSeed);
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d index = %h", 5, l2_bank_index);
           // force `TOP.cpu.l2t5.csr.arbadr_data_ecc_idx = l2_bank_index;
           force `TOP.cpu.l2t5.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
           force `TOP.cpu.l2t5.arbadr.arb_data_ecc_idx_en = 1;
         end

         else begin
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB RTL bank %d index = %h", 5, `TOP.cpu.l2t5.csr.arbadr_data_ecc_idx);
         end

         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

         // 2 release the forces.
         release `TOP.cpu.l2t5.csr.scrub_counter;
         release `TOP.cpu.l2t5.csr.csr_l2_control_reg[14:3];
         // if (indexType == 1) release `TOP.cpu.l2t5.csr.arbadr_data_ecc_idx;
         if (indexType == 1) release `TOP.cpu.l2t5.arbadr.arbadr_data_ecc_idx_plus1;
         if (indexType == 1) release `TOP.cpu.l2t5.arbadr.arb_data_ecc_idx_en;

         // 3 wait for the scrub to be signaled (posedge csr_filbuf_scrub_ready).
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on csr_filbuf_scrub_ready (scrub counter matching)", 5);
         @(posedge `TOP.cpu.l2t5.csr.csr_filbuf_scrub_ready);
         rtl_idx = `TOP.cpu.l2t5.csr.scrub_addr;

         // 3 wait for scrub to start
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en assert (wait for scrub to start)", 5);                               
         @(posedge `TOP.cpu.l2t5.tagctl.scrub_fsm_en);

         // 4 wait for scrub to be done (all ways)
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en de-assert(scrub has started, wait for finish)", 5);                              
         @(negedge `TOP.cpu.l2t5.tagctl.scrub_fsm_en);
         scrub_count5 = scrub_count5+1;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d scrub has finished (count=%d)", 5,scrub_count5);

         // check index incrementing
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         if (rtl_idx == `TOP.cpu.l2t5.csr.scrub_addr)
           `PR_ERROR ("l2_scrub", `ERROR, "ERROR: bank 5 RTL did not increment the scrub index!");

       end // 5 while 1
     end
   end
 endtask


 // 1) force the counter to a high value for 2 clocks,
 //    force the scrub index to a random value.
 // 2) release the forces.
 // 3) wait for the scrub (posedge csr_filbuf_scrub_ready).
 // 4) wait for scrub to be done (posedge filbuf.fb_tecc_pend_reset)
 // 5) repeat
 task scrubBank6;
   input l2_bank_index;

   reg [8:0] l2_bank_index;
   reg [12:0] rtl_idx;
   reg [11:0] randVal;
   reg [31:0] value;
   
   begin


$strobe("1 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",6,`PARGS.seed,localSeed);


     if (`TOP.cpu.ncu_l2t_pm == 0 || 
         (`TOP.cpu.ncu_l2t_pm == 1 && `TOP.cpu.ncu_l2t_ba67 == 1)) begin
       // initial skew between banks
       repeat ($random(localSeed)%16) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

       if (indexType == 2) begin
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d starting index = %h", 6, l2_bank_index);
         force `TOP.cpu.l2t6.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
         force `TOP.cpu.l2t6.arbadr.arb_data_ecc_idx_en = 1;
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         release `TOP.cpu.l2t6.arbadr.arbadr_data_ecc_idx_plus1;
         release `TOP.cpu.l2t6.arbadr.arb_data_ecc_idx_en;
       end

       while (1) begin

$strobe("2 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",6,`PARGS.seed,localSeed);

         // set counter to be valueIn clocks away from matching
         // {csr_l2_control_reg[14:3], 20'b0}.
         // Pick csr_l2_control_reg[14:3] at random then subtract
         // valueIn. Force this new value into the scrub_counter so
         // it will count up naturally and then match.
         randVal = $random(localSeed);
         if (randVal == 12'hfff) randVal = 12'hffe;
         if (randVal == 0) randVal = 1;
         value = {randVal,20'h0} - scrub_freq;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d scrub_counter = %d", 6,value);
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d csr_l2_control_reg[14:3] = %d", 6, randVal);
         force `TOP.cpu.l2t6.csr.scrub_counter = value;
         force `TOP.cpu.l2t6.csr.csr_l2_control_reg[14:3] = randVal;
         force `TOP.cpu.l2t6.csr.csr_l2_control_reg[2] = 1;

         if (indexType == 1) begin
           l2_bank_index = $random(localSeed);
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d index = %h", 6, l2_bank_index);
           // force `TOP.cpu.l2t6.csr.arbadr_data_ecc_idx = l2_bank_index;
           force `TOP.cpu.l2t6.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
           force `TOP.cpu.l2t6.arbadr.arb_data_ecc_idx_en = 1;
         end

         else begin
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB RTL bank %d index = %h", 6, `TOP.cpu.l2t6.csr.arbadr_data_ecc_idx);
         end

         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

         // 2 release the forces.
         release `TOP.cpu.l2t6.csr.scrub_counter;
         release `TOP.cpu.l2t6.csr.csr_l2_control_reg[14:3];
         // if (indexType == 1) release `TOP.cpu.l2t6.csr.arbadr_data_ecc_idx;
         if (indexType == 1) release `TOP.cpu.l2t6.arbadr.arbadr_data_ecc_idx_plus1;
         if (indexType == 1) release `TOP.cpu.l2t6.arbadr.arb_data_ecc_idx_en;

         // 3 wait for the scrub to be signaled (posedge csr_filbuf_scrub_ready).
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on csr_filbuf_scrub_ready (scrub counter matching)", 6);
         @(posedge `TOP.cpu.l2t6.csr.csr_filbuf_scrub_ready);
         rtl_idx = `TOP.cpu.l2t6.csr.scrub_addr;

         // 3 wait for scrub to start
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en assert (wait for scrub to start)", 6);                               
         @(posedge `TOP.cpu.l2t6.tagctl.scrub_fsm_en);

         // 4 wait for scrub to be done (all ways)
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en de-assert(scrub has started, wait for finish)", 6);                              
         @(negedge `TOP.cpu.l2t6.tagctl.scrub_fsm_en);
         scrub_count6 = scrub_count6+1;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d scrub has finished (count=%d)", 6,scrub_count6);

         // check index incrementing
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         if (rtl_idx == `TOP.cpu.l2t6.csr.scrub_addr)
           `PR_ERROR ("l2_scrub", `ERROR, "ERROR: bank 6 RTL did not increment the scrub index!");

       end // 5 while 1
     end
   end
 endtask


 // 1) force the counter to a high value for 2 clocks,
 //    force the scrub index to a random value.
 // 2) release the forces.
 // 3) wait for the scrub (posedge csr_filbuf_scrub_ready).
 // 4) wait for scrub to be done (posedge filbuf.fb_tecc_pend_reset)
 // 5) repeat
 task scrubBank7;
   input l2_bank_index;

   reg [8:0] l2_bank_index;
   reg [12:0] rtl_idx;
   reg [11:0] randVal;
   reg [31:0] value;
   
   begin


$strobe("1 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",7,`PARGS.seed,localSeed);


     if (`TOP.cpu.ncu_l2t_pm == 0 || 
         (`TOP.cpu.ncu_l2t_pm == 1 && `TOP.cpu.ncu_l2t_ba67 == 1)) begin
       // initial skew between banks
       repeat ($random(localSeed)%16) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

       if (indexType == 2) begin
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d starting index = %h", 7, l2_bank_index);
         force `TOP.cpu.l2t7.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
         force `TOP.cpu.l2t7.arbadr.arb_data_ecc_idx_en = 1;
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         release `TOP.cpu.l2t7.arbadr.arbadr_data_ecc_idx_plus1;
         release `TOP.cpu.l2t7.arbadr.arb_data_ecc_idx_en;
       end

       while (1) begin

$strobe("2 bank %0d PARGS.seed=%d, l2_scrub.localSeed=%d",7,`PARGS.seed,localSeed);

         // set counter to be valueIn clocks away from matching
         // {csr_l2_control_reg[14:3], 20'b0}.
         // Pick csr_l2_control_reg[14:3] at random then subtract
         // valueIn. Force this new value into the scrub_counter so
         // it will count up naturally and then match.
         randVal = $random(localSeed);
         if (randVal == 12'hfff) randVal = 12'hffe;
         if (randVal == 0) randVal = 1;
         value = {randVal,20'h0} - scrub_freq;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d scrub_counter = %d", 7,value);
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB seting bank %d csr_l2_control_reg[14:3] = %d", 7, randVal);
         force `TOP.cpu.l2t7.csr.scrub_counter = value;
         force `TOP.cpu.l2t7.csr.csr_l2_control_reg[14:3] = randVal;
         force `TOP.cpu.l2t7.csr.csr_l2_control_reg[2] = 1;

         if (indexType == 1) begin
           l2_bank_index = $random(localSeed);
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB set bank %d index = %h", 7, l2_bank_index);
           // force `TOP.cpu.l2t7.csr.arbadr_data_ecc_idx = l2_bank_index;
           force `TOP.cpu.l2t7.arbadr.arbadr_data_ecc_idx_plus1 = l2_bank_index;
           force `TOP.cpu.l2t7.arbadr.arb_data_ecc_idx_en = 1;
         end

         else begin
           `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB RTL bank %d index = %h", 7, `TOP.cpu.l2t7.csr.arbadr_data_ecc_idx);
         end

         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);

         // 2 release the forces.
         release `TOP.cpu.l2t7.csr.scrub_counter;
         release `TOP.cpu.l2t7.csr.csr_l2_control_reg[14:3];
         // if (indexType == 1) release `TOP.cpu.l2t7.csr.arbadr_data_ecc_idx;
         if (indexType == 1) release `TOP.cpu.l2t7.arbadr.arbadr_data_ecc_idx_plus1;
         if (indexType == 1) release `TOP.cpu.l2t7.arbadr.arb_data_ecc_idx_en;

         // 3 wait for the scrub to be signaled (posedge csr_filbuf_scrub_ready).
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on csr_filbuf_scrub_ready (scrub counter matching)", 7);
         @(posedge `TOP.cpu.l2t7.csr.csr_filbuf_scrub_ready);
         rtl_idx = `TOP.cpu.l2t7.csr.scrub_addr;

         // 3 wait for scrub to start
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en assert (wait for scrub to start)", 7);                               
         @(posedge `TOP.cpu.l2t7.tagctl.scrub_fsm_en);

         // 4 wait for scrub to be done (all ways)
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d waiting on scrub_fsm_en de-assert(scrub has started, wait for finish)", 7);                              
         @(negedge `TOP.cpu.l2t7.tagctl.scrub_fsm_en);
         scrub_count7 = scrub_count7+1;
         `PR_NORMAL ("l2_scrub", `NORMAL,"L2_SCRUB bank %d scrub has finished (count=%d)", 7,scrub_count7);

         // check index incrementing
         repeat (2) @(posedge `TOP.cpu.cmp_gclk_c3_l2t0);
         if (rtl_idx == `TOP.cpu.l2t7.csr.scrub_addr)
           `PR_ERROR ("l2_scrub", `ERROR, "ERROR: bank 7 RTL did not increment the scrub index!");

       end // 5 while 1
     end
   end
 endtask


`endif

`endif


`endif

`endif

endmodule