// ========== Copyright Header Begin ==========================================
// 
// OpenSPARC T2 Processor File: niu_rxdma_pktchk.vr
// 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 ============================================
#include <vera_defines.vrh>
#include <ListMacros.vrh>
#include "niu_rx_crentry.vrh"
#include "niu_rxdmc.vrh"
#include "niu_rxtoken.vrh"
#include "niu_rxdma_pkttab.vrh"
#include "niu_byte_array.vrh"
#include "niu_mem.vrh"
#include "mbox_class.vrh"
#include "get_mbox_id.vrh"
#include "niu_rxtoken.vrh"
#include "dmc_memory_map.vri"
#include "cMesg.vrh"
#include "niu_rx_test_util.vrh"
#include "niu_int_mgr.vrh"
#include "niu_rx_exit_tools.vrh"

#ifdef NEPTUNE
 #define MAX_PORTS 4
#else
 #define MAX_PORTS 2
#endif

extern niu_gen_pio gen_pio_drv;
extern Mesg be_msg;
extern mbox_class mbox_id;
extern CSparseMem SparseMem;
extern CRDMC rdmc;
extern event RX_chk_done;
extern integer RX_TEST_REACHED_END;

extern CNiuIntrMgr NiuIntrMgr;

#define CR_L2_ERROR 1

class CRxDmaPktChk {
  bit[3:0] last_packet_seen;
  bit[3:0] ports_active;
  integer debug_en=0;
  integer packets_remaining[4];
  integer packets_checked[4], total_packets_sent[4];
  integer packets_dropped[4], packets_l2_errors[4];
  integer check_done = 0;
  integer interrupts_enabled;
  integer ignore_address_mismatch = 0;
  CRxPacketScoreBoard PacketScoreBoard[4];
  niu_rx_test_util niu_rx_test_util;
  rx_exit_tools rx_exit_tools;
  task watch_for_last_pkt_and_flush();
  task SpCRCheckPacket();
  task check_packet(Ccr_entry cr[*], integer dma_no, integer no_of_scatters, integer index);
  task readPacketfromMem(bit[63:0] address, integer length, var byte_array readpacket, integer offset);
  task check_for_last_packet(CRxToken RxToken);
  task check_control_header(CRxToken RxToken, byte_array readpacket);
  task collectStats();
  task UpdateRCRStat( integer no_of_entries_to_check,integer pkts_checked, integer scatters[*],integer dma_no) ;
  task RCR_FLUSH_START_pio_wr(bit [63:0] address, bit [63:0] data, integer dma);
  local function integer WaitForCrTobeWritten(var integer dma_no) ;

  local task  free_memory(CRxToken RxToken ,integer dma_no);
  task rx_exit_routine(integer mac_id);
  task match_xmac_status(integer mac_id, bit[31:0] status);
  task match_bmac_status(integer mac_id, bit[31:0] status);


  task new() {
    string init_mac_ports,temp_port;
    bit[31:0] get_mac_port;
    integer i;
    integer rxdma_pthres_intr,rxdma_timer_intr;
    interrupts_enabled = 0; 

    niu_rx_test_util = new;


    if(mbox_id.niu_rxpath_cr == -1) {
      mbox_id.niu_rxpath_cr = alloc(MAILBOX,0,1);
    }

    fork
     SpCRCheckPacket();
    join none

    fork 
      watch_for_last_pkt_and_flush();
    join none

    ports_active = 0;
    last_packet_seen =0;
    if(get_plus_arg( CHECK, "SKIP_ADDRESS_CHECK")) {
      // This flag has to be used for randoms only for cases where
      // descriptor ring is getting empty. For all other cases this flag should not be used
      ignore_address_mismatch = 1;
    } else ignore_address_mismatch = 0;
    if(get_plus_arg( CHECK, "GET_MAC_PORTS="))
      get_mac_port = get_plus_arg( STR, "GET_MAC_PORTS=");

    init_mac_ports.bittostr(get_mac_port);
    for(i=0; i<init_mac_ports.len();i++) {
      temp_port =init_mac_ports.substr(i,i);
      ports_active = ports_active | ( 1<<temp_port.atoi());
    }
    for(i=0;i<4;i++) {
      packets_remaining[i] = 0;
      packets_checked[i] = 0;
      total_packets_sent[i] =0;
      packets_dropped[i] = 0;
      packets_l2_errors[i] = 0;
      if(ports_active[i]) PacketScoreBoard[i] = new(i);
    }
    if(get_plus_arg( CHECK, "RXDMA_PTHRESH_INTR_CHKR="))
        rxdma_pthres_intr = get_plus_arg(HNUM,"RXDMA_PTHRESH_INTR_CHKR=");
     else rxdma_pthres_intr=0;
    if(get_plus_arg (CHECK,"RXDMA_TIMER_INTR_CHKR="))
         rxdma_timer_intr = get_plus_arg(HNUM,"RXDMA_TIMER_INTR_CHKR=");
     else rxdma_timer_intr = 0;

    interrupts_enabled = ( rxdma_pthres_intr | rxdma_timer_intr) ;
    printf ("rxdma_pthres_intr=0x%h, rxdma_timer_intr=0x%h, interrupts_enabled=0x%h\n", rxdma_pthres_intr,rxdma_timer_intr,interrupts_enabled);
  } // new
} //class


function integer CRxDmaPktChk::WaitForCrTobeWritten(var integer dma_no) {
 integer no_of_entries;
 Ccr_update cr_update;

 no_of_entries = mailbox_get(WAIT,mbox_id.niu_rxpath_cr, cr_update);
 dma_no = cr_update.dma_no;
 WaitForCrTobeWritten = cr_update.no_of_entries;
}

task CRxDmaPktChk::watch_for_last_pkt_and_flush() {
  bit[3:0] last_seen=4'b0000;
  shadow integer dma;

  repeat(1000) @(posedge CLOCK); // This delay is a MUST

  while(last_seen !== ports_active ) {
    if(ports_active[0]) last_seen[0]=PacketScoreBoard[0].last_pkt_rcvd;
    if(ports_active[1]) last_seen[1]=PacketScoreBoard[1].last_pkt_rcvd;
    if(ports_active[2]) last_seen[2]=PacketScoreBoard[2].last_pkt_rcvd;
    if(ports_active[3]) last_seen[3]=PacketScoreBoard[3].last_pkt_rcvd;
    repeat(1000) @(posedge CLOCK);
  }
  if(get_plus_arg( CHECK, "RX_LAST_PKT_LATENCY="))
    repeat( get_plus_arg( NUM, "RX_LAST_PKT_LATENCY=") ) @(posedge CLOCK);
  else
    repeat(5000) @(posedge CLOCK);

  // RCR flush of all 16 DMAs
  for(dma=0;dma<16;dma++) {
   fork {
    rdmc.rx_dma[dma].flush_rcr(1);
   } join all
  }

  // kick in the timer interrupt to flush out the residual interrupts from all DMAs
  niu_rx_test_util.cleanup_dma_interrupts(interrupts_enabled) ;

  printf("check_packet RX_TEST_REACHED_END (all dmas flushed) time=%0d\n", {get_time(HI),get_time(LO)});
  RX_TEST_REACHED_END = 1;
}


task CRxDmaPktChk::SpCRCheckPacket() {
  Ccr_entry cr[*];
  integer i, no_of_entries;
  integer status, dma_no;
  integer start_index, no_of_scatter;
  integer prev_remaining_entries[32];
  integer no_of_entries_to_check;
  integer pkts_checked;
  bit [63:0] rd_data_;
  integer scatters[*];
  integer none_found;
  integer done_with_while;


  for(i=0; i<32; i++) prev_remaining_entries[i]=0;

  while(1) {
    no_of_entries = WaitForCrTobeWritten(dma_no); //get dma_no and no_of_entries
    //printf("check_packet dma=%0d no_of_entries=%0d prev_remaining_entries=%0d\n", dma_no, no_of_entries, prev_remaining_entries[dma_no]);
   no_of_entries = no_of_entries + prev_remaining_entries[dma_no];

if(no_of_entries >rdmc.rx_dma[dma_no].completionring.ring_length ) {
   be_msg.print(e_mesg_error,"CRxDmaPktChk","SpCRCheckPacket","CR_no_of_entries > RCR_RING_LEN at time %0d. Exiting the simulation \n", get_time(LO));
   repeat(300) @(posedge CLOCK);
   exit(0);
}
   status = rdmc.rx_dma[dma_no].completionring.ReadCrEntry(no_of_entries,cr);
  
   // parse entries
   if(cr[no_of_entries-1].multi==0) {
     prev_remaining_entries[dma_no] =0;
     no_of_entries_to_check = no_of_entries;
   }
   else {    //scan through the list and get the complete packet
     if(no_of_entries ==1) {
       no_of_entries_to_check =0;
       prev_remaining_entries[dma_no] =1;
     }
     else {
       i= no_of_entries-1;
       none_found = 0;
       done_with_while = 0;
       while( (done_with_while==0) && ( none_found==0) )  { 
	if(cr[i].multi==0 ) {
	  done_with_while = 1;
	  i++;
        }
        i--;
	if(i<0) none_found = 1;
       }
       if(none_found) {
        no_of_entries_to_check = 0;
       } else {
        no_of_entries_to_check = i + 1;
       }
       prev_remaining_entries[dma_no] = no_of_entries - no_of_entries_to_check ;
     }
   }
   printf("check_packet dma=%0d num_entries_to_check=%0d num_entries=%0d prev_remaining_entries=%0d\n", dma_no, no_of_entries_to_check, no_of_entries, prev_remaining_entries[dma_no]);
   
   rdmc.rx_dma[dma_no].completionring.UpdateCRLastAddress(no_of_entries_to_check);

   pkts_checked = 0;
   scatters = new[no_of_entries_to_check];

   for(i=0; i<no_of_entries_to_check; i++) {
     if(cr[i].multi==0) {
       check_packet(cr, dma_no, 1, i);
       scatters[pkts_checked] = 1;
       pkts_checked++;
     }
     else {               // jumbo packets - collect all the cr entries
       no_of_scatter = 1;
       start_index = i;
       while(cr[i].multi==1) {
         no_of_scatter ++;
         i++;	
       } 
       check_packet(cr, dma_no, no_of_scatter, start_index);
       scatters[pkts_checked] = no_of_scatter;
       pkts_checked++;
     }
   }
   @(posedge CLOCK);
   UpdateRCRStat(no_of_entries_to_check,pkts_checked,scatters,dma_no);

  }
}

task CRxDmaPktChk::UpdateRCRStat( integer no_of_entries_to_check,integer pkts_checked, integer scatters[*],integer dma_no) {
Crcr_update rcr_update;
integer i;
  
  if (get_plus_arg( CHECK, "CHKR_AUTO_UPDATE_RCR_HEAD")) {
   rcr_update = new();
   rcr_update.no_of_entries = no_of_entries_to_check;
   rcr_update.dma_no = dma_no;
   rcr_update.pkts_checked = pkts_checked;
   rcr_update.scatters= new[no_of_entries_to_check];
   for(i=0;i<pkts_checked;i++) {
    rcr_update.scatters[i] = scatters[i];
   }
   mailbox_put(mbox_id.niu_rxpath_rcr_update[dma_no], rcr_update); 
  }

}

task CRxDmaPktChk::check_control_header(  CRxToken RxToken, byte_array readpacket ) {
  bit [7:0] exp_cntl_hdr_B0, exp_cntl_hdr_B1, rtl_cntl_hdr_B0, rtl_cntl_hdr_B1;
  bit [1:0] exp_port_num, rtl_port_num, exp_tres, rtl_tres; 
  bit       exp_maccheck, rtl_maccheck;
  bit [4:0] exp_packet_class, rtl_packet_class;
  bit exp_vlan,exp_llcsnap,exp_noport,exp_badip,exp_tcamhit,exp_tzfvld;
  bit rtl_vlan,rtl_llcsnap,rtl_noport,rtl_badip,rtl_tcamhit,rtl_tzfvld;

 // Collect the expected control header fields
    exp_cntl_hdr_B0 	= RxToken.rx_cntl_hdr.val[0];
    exp_cntl_hdr_B1 	= RxToken.rx_cntl_hdr.val[1];

    exp_port_num 	= exp_cntl_hdr_B0[7:6];
    exp_maccheck 	= exp_cntl_hdr_B0[5];
    exp_packet_class 	= exp_cntl_hdr_B0[4:0];
    exp_vlan 		= exp_cntl_hdr_B1[7];
    exp_llcsnap 	= exp_cntl_hdr_B1[6];
    exp_noport 		= exp_cntl_hdr_B1[5];
    exp_badip 		= exp_cntl_hdr_B1[4];
    exp_tcamhit 	= exp_cntl_hdr_B1[3];
    exp_tres 		= exp_cntl_hdr_B1[2:1];
    exp_tzfvld 		= exp_cntl_hdr_B1[0];


 // Collect the RTL control header fields got from memory
    rtl_cntl_hdr_B0	= readpacket.val[0];
    rtl_cntl_hdr_B1	= readpacket.val[1];

    rtl_port_num 	= rtl_cntl_hdr_B0[7:6];
    rtl_maccheck 	= rtl_cntl_hdr_B0[5];
    rtl_packet_class 	= rtl_cntl_hdr_B0[4:0];
    rtl_vlan 		= rtl_cntl_hdr_B1[7];
    rtl_llcsnap 	= rtl_cntl_hdr_B1[6];
    rtl_noport 		= rtl_cntl_hdr_B1[5];
    rtl_badip 		= rtl_cntl_hdr_B1[4];
    rtl_tcamhit 	= rtl_cntl_hdr_B1[3];
    rtl_tres 		= rtl_cntl_hdr_B1[2:1];
    rtl_tzfvld 		= rtl_cntl_hdr_B1[0];



	printf("CNTL_HDR_CHECK: ---------------------------------------------------\n");
	printf("CNTL_HDR_CHECK:     RX CONTROL HEADER CHECK IN PKT_DROP CHECKER    \n");
	printf("CNTL_HDR_CHECK: ---------------------------------------------------\n");
	printf("CNTL_HDR_CHECK: 		  RTL		MODEL              \n");
	printf("CNTL_HDR_CHECK: ---------------------------------------------------\n");

	if (rtl_tzfvld!==exp_tzfvld)
	be_msg.print(e_mesg_error,"CNTL_HDR_CHECK", "", "TZFVLD		= %0h\t\t%0h\n", rtl_tzfvld, exp_tzfvld);
	else
	printf("CNTL_HDR_CHECK: TZFVLD		= %0h\t\t%0h\n", rtl_tzfvld, exp_tzfvld);
	if (rtl_tres!==exp_tres)
	be_msg.print(e_mesg_error,"CNTL_HDR_CHECK", "", "TRES		= %0h\t\t%0h\n", rtl_tres, exp_tres);	
	else
	printf("CNTL_HDR_CHECK: TRES		= %0h\t\t%0h\n", rtl_tres, exp_tres);	
	if (rtl_tcamhit!==exp_tcamhit)
	be_msg.print(e_mesg_error,"CNTL_HDR_CHECK", "", "TCAM-Hit	= %0h\t\t%0h\n", rtl_tcamhit, exp_tcamhit);
	else
	printf("CNTL_HDR_CHECK: TCAM-Hit	= %0h\t\t%0h\n", rtl_tcamhit, exp_tcamhit);
	if (exp_badip!==exp_badip)
	be_msg.print(e_mesg_error,"CNTL_HDR_CHECK", "", "Bad-IP		= %0h\t\t%0h\n", exp_badip, exp_badip);
	else
	printf("CNTL_HDR_CHECK: Bad-IP		= %0h\t\t%0h\n", exp_badip, exp_badip);
	if (rtl_noport!==exp_noport)
	be_msg.print(e_mesg_error,"CNTL_HDR_CHECK", "", "No-port		= %0h\t\t%0h\n", rtl_noport, exp_noport);
	else
	printf("CNTL_HDR_CHECK: No-port		= %0h\t\t%0h\n", rtl_noport, exp_noport);
	if (rtl_llcsnap!==exp_llcsnap)
	be_msg.print(e_mesg_error,"CNTL_HDR_CHECK", "", "LLC-SNAP	= %0h\t\t%0h\n", rtl_llcsnap, exp_llcsnap);
	else
	printf("CNTL_HDR_CHECK: LLC-SNAP	= %0h\t\t%0h\n", rtl_llcsnap, exp_llcsnap);
	if (rtl_vlan!==exp_vlan)
	be_msg.print(e_mesg_error,"CNTL_HDR_CHECK", "", "VLAN		= %0h\t\t%0h\n", rtl_vlan, exp_vlan);
	else
	printf("CNTL_HDR_CHECK: VLAN		= %0h\t\t%0h\n", rtl_vlan, exp_vlan);
	if (rtl_packet_class!==exp_packet_class)
	be_msg.print(e_mesg_error,"CNTL_HDR_CHECK", "", "CLASS		= %0h\t\t%0h\n", rtl_packet_class, exp_packet_class);
	else
	printf("CNTL_HDR_CHECK: CLASS		= %0h\t\t%0h\n", rtl_packet_class, exp_packet_class);
	if (rtl_maccheck!==exp_maccheck)
	be_msg.print(e_mesg_error,"CNTL_HDR_CHECK", "", "MAC-check	= %0h\t\t%0h\n", rtl_maccheck, exp_maccheck);
	else
	printf("CNTL_HDR_CHECK: MAC-check	= %0h\t\t%0h\n", rtl_maccheck, exp_maccheck);
	if (rtl_port_num!==exp_port_num)
	be_msg.print(e_mesg_error,"CNTL_HDR_CHECK", "", "MAC-PORT	= %0h\t\t%0h\n", rtl_port_num, exp_port_num);
	else
	printf("CNTL_HDR_CHECK: MAC-PORT	= %0h\t\t%0h\n", rtl_port_num, exp_port_num);
	printf("CNTL_HDR_CHECK: ---------------------------------------------------\n");
 

}

task CRxDmaPktChk::check_packet(Ccr_entry cr[*], integer dma_no, integer no_of_scatters, integer index) {
  bit[63:0] packet_address;
  bit[63:0] xlate_packet_address;
  integer length, total_length;
  integer i, block_size, page_id;
  byte_array readpacket, expected_packet;
  bit[15:0] packet_id;
  CRxToken RxToken;
  integer mac_id, gId;
  integer status;
  integer n, bytes_mismatched, total_offset;
  byte_array ctrlhdr;
  integer port_num_from_pkt;
  integer error_status;
  integer skip_checking;
  integer getaddr_status;
  integer offset = 0;
  integer expected_dma_no,expected_port_no,dma_no_from_pkt;

  total_offset = rdmc.rx_dma[dma_no].ctrl_hdr_len + rdmc.rx_dma[dma_no].buffer_offset;
  total_length = cr[index].length + total_offset/*header_length*/;
  block_size = rdmc.rx_dma[dma_no].dma_block_size;
  
  readpacket = new();
  printf("check_packet  index=%0d num_scatters=%0d length=%0d\n", index, no_of_scatters, total_length);

  length = total_length;
  for(i=0;i<no_of_scatters;i++) {
    xlate_packet_address=64'h0;
    packet_address = cr[i+index].pkt_buf_address;
    page_id = rdmc.rx_dma[dma_no].getPageId(packet_address);
    // page_id = 64 + 2*dma_no; 
    if(page_id==-1)
      be_msg.print(e_mesg_error, "niu_rx_chkr", "check_packet", "PacketBuf Addr in CR doesnt Match Any valid page!!\n");
    else {
      xlate_packet_address = SparseMem.xlate_addr( packet_address[39:0], page_id );
    }
    // length = min(block_size, total_length);
    if(block_size<length)
      length = block_size;
    //printf("check_packet dma=%0d min block_size=%0d length=%0d\n", dma_no, block_size, length);
    printf("check_packet  xlated_addr=0x%0h orig_addr=0x%0h page_id=%0d\n", xlate_packet_address, packet_address, page_id);
   
    // length = (block_size<length) ? block_size: length;
    readPacketfromMem(xlate_packet_address, length, readpacket, offset);
    offset = offset + length; 
    length = total_length - offset;
  }

  ctrlhdr = new();
  for(i=0; i<total_offset; i++) {
    ctrlhdr.val[i] = readpacket.val[i];
  }

  if (rdmc.rx_dma[dma_no].ctrl_hdr_len == 2)
    port_num_from_pkt = ( ctrlhdr.val[0] & 8'hc0)>>6;
  else if (rdmc.rx_dma[dma_no].ctrl_hdr_len == 18) // for 18B hdr, second cycle has the port_num info
    port_num_from_pkt = ( ctrlhdr.val[16] & 8'hc0)>>6;

  packet_id = {readpacket.val[total_offset+6+4],readpacket.val[total_offset+6+5]};

  
  expected_port_no = readpacket.val[total_offset + 6 + 3] & 8'h3;
  expected_dma_no = ({readpacket.val[total_offset + 6 + 2], readpacket.val[total_offset + 6 + 3]}>>2) & 8'h3f; 
  dma_no_from_pkt = ({readpacket.val[total_offset + 6 + 2], readpacket.val[total_offset + 6 + 3]}>>2) & 8'h3f; 

  error_status = cr[index].errors;
  skip_checking = 0;
  
  if(error_status == CR_L2_ERROR) {
    // for L2 Error the expected DMA is the port default DMA
    expected_dma_no = rdmc.getPortDefDma(expected_port_no);
    rdmc.rx_dma[expected_dma_no].incDefPktCnt();
   } else {
    rdmc.rx_dma[dma_no].incPktCnt();
  }

  if(expected_dma_no!=dma_no) {
    printf(" RTL_MODEL DMA PREDICTION MISMATCH ERROR!!! packet_id - %0d, Mismatch in DMA no exp - %0d, got - %0d port_num %0d\n",
 	packet_id, expected_dma_no, dma_no, expected_port_no);
   } 
   
  if(expected_port_no!=port_num_from_pkt) {
    printf(" RTL_MODEL PORT MISMATCH ERROR!!! packet_id - %0d, Mismatch in Port No exp - %0d, got - %0d port_num %0d\n",
 	packet_id, expected_port_no, port_num_from_pkt, expected_port_no);
   } 

  printf("check_packet  mac.seq=%0d.%0d\n", port_num_from_pkt, packet_id);

  if(error_status == CR_L2_ERROR) { //for unexpected L2 Error cases only due to runts 
                                    //caused by ipp back pressure
    PacketScoreBoard[port_num_from_pkt].no_of_packets_l2_errors++;
    PacketScoreBoard[port_num_from_pkt].no_of_bytes_l2_errors = PacketScoreBoard[port_num_from_pkt].no_of_bytes_l2_errors + cr[index].length;
    printf("check_packet Packet at addr=0x%x cr_address=0x%x received with L2 error\n", packet_address, cr[index].address);
    //printf("check_packet PACKET_CHECKING SKIPPED!! \n");
    skip_checking = 1;
  }

  status = PacketScoreBoard[port_num_from_pkt].getPacket(packet_id, RxToken, dma_no,dma_no_from_pkt);

  // At this point, we have RxToken. Check the control header here.
 if(get_plus_arg (CHECK, "ENABLE_RX_CNTL_HDR_CHECK")) {
    check_control_header(RxToken,readpacket);
 }

  // calculate expected address
  // calculate expected completion ring entry

// #ifdef 0
  if(status==1) {
    RxToken.pkt_length = total_length - total_offset;
    getaddr_status = rdmc.rx_dma[dma_no].getPacketAddress(RxToken);
    // various compare points
    if(RxToken.NoOfScatter!==no_of_scatters) {
     printf("ERROR Expected RxToken.NoOfScatter - %d Actual no_of_scatters - %d \n",RxToken.NoOfScatter,no_of_scatters);
    }
    for(i=0;i<RxToken.NoOfScatter;i++) {
      if(RxToken.packet_virtaddress[i]!== cr[i+index].pkt_buf_address) {
	if(ignore_address_mismatch) 
           printf("ADDRESS MISMATCH WARNING !!! RxToken.packet_virtaddr[%0d]=0x%x, cr[%0d].pkt_buf_address=0x%x\n", i, RxToken.packet_virtaddress[i], i+index, cr[i+index].pkt_buf_address);
        else 
           printf("ADDRESS MISMATCH ERROR !!! RxToken.packet_virtaddr[%0d]=0x%x, cr[%0d].pkt_buf_address=0x%x\n", i, RxToken.packet_virtaddress[i], i+index, cr[i+index].pkt_buf_address);
      }
    }
   } 
// #endif

  if(skip_checking) printf("check_packet PACKET_CHECKING SKIPPED!! FIX IT \n");
  else if(status == -1) be_msg.print(e_mesg_error, "niu_rx_chkr", "check_packet", "Illegal Packet received Id=%0d\n", packet_id);
  // do a sanity check on the status
  else {
    expected_packet = RxToken.pgToken.buf;
    mac_id = RxToken.port_num;
    gId = RxToken.id;
    if(port_num_from_pkt!==mac_id) be_msg.print(e_mesg_error, "niu_rx_chkr", "check_packet", "PortNum from Packet=%0d  Exp Port Num=%0d\n", port_num_from_pkt, mac_id); 

    for(n=0; n<total_length-total_offset;n =n+1) {
      if(expected_packet.val[n] !== readpacket.val [n+total_offset]) { // check after "total_offset" number of Bytes
        be_msg.print(e_mesg_error, "niu_rx_chkr", "check_packet", "DATA_MISMATCH:niu_rx_chkr[%0d]: Token=%0d Word[%0d] Got=0x%0h Exp=0x%0h\n", mac_id, gId, n,readpacket.val[n+total_offset], expected_packet.val[n] );
        bytes_mismatched ++;
      }
      else {
        if(debug_en) {
          be_msg.print(e_mesg_info, "niu_rx_chkr", "check_packet", "Packet Successfully Written:niu_rx_chkr[%0d]: Token=%0d Word[%0d] Got=0x%0h Exp=0x%0h\n", mac_id, gId, n,readpacket.val[n+total_offset], expected_packet.val[n] );
        }
      }
    }
  }
  fork {
     check_for_last_packet(RxToken); 
  } join none

  if(status==1)
   free_memory(RxToken,expected_dma_no);
  printf("check_packet  ========== done with entry \n");
}

	task  CRxDmaPktChk::free_memory(CRxToken RxToken ,integer dma_no){
    rdmc.rx_dma[dma_no ].free_memory(RxToken);
}

task CRxDmaPktChk::readPacketfromMem(bit[63:0] address, integer length, var byte_array readpacket, integer offset) {
  integer NoOf8Bytes, index, j;
  bit[63:0] mem_rd_data;
  bit[63:0] mem_rd_addr;

  mem_rd_addr = address;
  NoOf8Bytes = ( (length)/8) + ( ((length) %8) ? 1 :0 ) ;
  printf("check_packet  readPacketfromMem length=%0d addr=0x%x offset=%0d\n", length, address, offset);
  for(index=0; index<NoOf8Bytes; index ++) {
    SparseMem.ReadMem(mem_rd_addr + 8*index, mem_rd_data, 8'hff);
    for(j=0; j<8; j++) {
      readpacket.val[offset+ 8*index +j] = mem_rd_data[ 8*j + 7: 8*j]; 
      // printf("CRxDmaPktChk::readPacketfromMem index - %d byte - %x \n",(offset+ 8*index + j),readpacket.val[offset+ 8*index + j]);
    }
  }
}


task CRxDmaPktChk::check_for_last_packet(CRxToken RxToken) {
  shadow integer dma;
  integer port_num, dma_num;

  bit[31:0] dma_active_list;
  bit[31:0] dma_done_list;

  if(RxToken.last_packet) {
    last_packet_seen[RxToken.port_num] = 1;

    printf("check_packet port_active=0x%0h last_packet_seen=%0d\n", ports_active, last_packet_seen);
    if(last_packet_seen ==  ports_active) {
      printf("check_packet Last Packet token received from all active ports time=%d \n",{get_time(HI), get_time(LO)});
      repeat(500) @(posedge CLOCK);
      check_done = 1;
      repeat(500) @(posedge CLOCK);

      if(get_plus_arg(CHECK, "RX_LAST_PKT_LATENCY="))
        repeat(get_plus_arg( NUM, "RX_LAST_PKT_LATENCY=")) @(posedge CLOCK);
      else
        repeat(5000) @(posedge CLOCK);

     // Wait for All the active CR Polls to be done before exiting
 
    
    for(dma=0; dma<16; dma++) { 
	dma_active_list = (rdmc.rx_dma[dma].poll_cr_active)<<dma;
	dma_done_list = (rdmc.rx_dma[dma].poll_cr_done)<<dma;
    }

   while((dma_active_list != dma_done_list)) {
      for(dma=0; dma<16; dma++) { 
	dma_active_list = (rdmc.rx_dma[dma].poll_cr_active)<<dma;
	dma_done_list = (rdmc.rx_dma[dma].poll_cr_done)<<dma;
      }
      repeat(100)@(posedge CLOCK);
   }

      for(dma=0; dma<16; dma++) {    //flush all 16 DMA Crings
       fork {
	rdmc.rx_dma[dma].flush_rcr(1);
       } join all
      }

     repeat(1000) @(posedge CLOCK); // 
    
    printf ("interrupts_enabled=0x%h\n", interrupts_enabled);
     if (interrupts_enabled) {
       niu_rx_test_util.cleanup_dma_interrupts(interrupts_enabled) ;
        repeat(1000) @(posedge CLOCK); // 
        repeat(1000) @(posedge CLOCK); // 
       NiuIntrMgr.CheckPendingFlags();
        repeat(1000) @(posedge CLOCK); // 
       NiuIntrMgr.CheckPendingFlags();
     }


      collectStats(); // for all ports

      trigger (ON, RX_chk_done);
    }
  }  
  // Do stats collection at this point
}
task CRxDmaPktChk::collectStats() {
  integer total_rtl_drop_count=0, rtl_mac_drop_count=0, rtl_ipp_drop_count=0, rtl_rdma_drop_count=0;
  integer total_env_drop_count=0;
  integer port_num, dma_num, TotalNoOfEntries=0;
  bit pkt_drop_expected, 
      pkt_drop_may_be_expected,
      env_rtl_mismatch_expected, 
      rtl_pkt_drop_count_non_zero, 
      env_pkt_drop_count_non_zero, 
      rtl_and_env_drop_count_matched;
  

  // collect total env drop count
  for(port_num=0;port_num<4;port_num++) {
      if(ports_active[port_num])
         total_env_drop_count += PacketScoreBoard[port_num].getNoOfEntries();
  }

  // collect rtl mac drop count
  for(port_num=0;port_num<4;port_num++) {
      if(ports_active[port_num])
  	 rtl_mac_drop_count += niu_rx_test_util.getMacDropCnt(port_num, 
	                                        PacketScoreBoard[port_num].no_of_packets_qued);
  }

  // collect rtl ipp drop count
  for(port_num=0;port_num<4;port_num++) {
      if(ports_active[port_num])
  	 rtl_ipp_drop_count += niu_rx_test_util.getIppDropCnt(port_num);
  }

  //printf("<%0d> collectStats: setting rtl_ipp_drop_count=0 mac and ipp increments cnt for the same pkt\n",
 // 	get_time(LO));
  //rtl_ipp_drop_count = 0;

  // collect rtl rdma drop count
  for(dma_num=0;dma_num<16;dma_num++) {
  	rtl_rdma_drop_count += niu_rx_test_util.getRdmcDropCnt(dma_num);
  }

  

  total_rtl_drop_count = rtl_mac_drop_count + rtl_ipp_drop_count + rtl_rdma_drop_count;

  // print PacketScoreBoard
  //for(port_num=0;port_num<4 && ports_active[port_num];port_num++) {
  //  PacketScoreBoard[port_num].print_stats();
  //}



  if (get_plus_arg(CHECK, "PKT_DROPS_EXPECTED")) pkt_drop_expected = 1;
  else pkt_drop_expected = 0;
  if (get_plus_arg(CHECK, "PKT_DROPS_MAY_BE_EXPECTED")) pkt_drop_may_be_expected = 1;
  else pkt_drop_may_be_expected = 0;
  if (get_plus_arg(CHECK, "ENV_RTL_MISMATCH_EXPECTED")) env_rtl_mismatch_expected = 1;
  else env_rtl_mismatch_expected = 0;

  rtl_pkt_drop_count_non_zero = total_rtl_drop_count ? 1: 0;
  env_pkt_drop_count_non_zero = total_env_drop_count ? 1: 0;
  rtl_and_env_drop_count_matched = (total_rtl_drop_count == total_env_drop_count) ? 1: 0;

  // print drop statistics
  printf("============================ check_packet : collectStats ========================\n");
  printf("collectStats rtl_mac_drop_count:%0d rtl_ipp_drop_count:%0d rtl_rdma_drop_count:%0d\n",
    	  rtl_mac_drop_count, rtl_ipp_drop_count, rtl_rdma_drop_count);
  printf("collectStats total_rtl_drop_count:%0d total_env_drop_count:%0d\n",
    	  total_rtl_drop_count, total_env_drop_count);
  printf("collectStats pkt_drop_expected:%b  pkt_drop_may_be_expected:%b\n",
          pkt_drop_expected, pkt_drop_may_be_expected);
  printf("rtl_pkt_drop_cnt_non_zero:%b, env_pkt_drop_cnt_non_zero:%b, rtl_and_env_drop_cnt_matched:%b\n",
          rtl_pkt_drop_count_non_zero, env_pkt_drop_count_non_zero, rtl_and_env_drop_count_matched);
  	
  // Analyze all the counters
  case ({pkt_drop_expected, 
         rtl_pkt_drop_count_non_zero, 
         env_pkt_drop_count_non_zero, 
	 rtl_and_env_drop_count_matched}) {
    4'b0001,    // PASS -- No pkts tests
    4'b1111: {} // PASS -- normal pkt drop not allowed tests
    4'b001X,    // FAIL -- drops are not allowed
    4'b0110,    // FAIL -- drop count mismatch
    4'b010X: {  // FAIL -- drop count mismatch
                if(!env_rtl_mismatch_expected)
                   be_msg.print(e_mesg_error, "niu_rxdma_pktchk", 
		       "collectStats", 
		       "ERROR : drop count mismatch between env and rtl!\n");
		else
                   be_msg.print(e_mesg_info, "niu_rxdma_pktchk",
                       "collectStats",
                       "drop count mismatch between env and rtl found, but is expected by the TEST!\n");
    }
    4'b0111: {  // FAIL -- drops are not allowed unless pkt_drop_may_be_expected is set
		if(!pkt_drop_may_be_expected)
                   be_msg.print(e_mesg_error, "niu_rxdma_pktchk", 
		       "collectStats", 
		       "drops are not allowed in this test. use PKT_DROPS_EXPECTED to allow drops\n");
		else
                   be_msg.print(e_mesg_info, "niu_rxdma_pktchk", 
		       "collectStats", 
		       "there are few drops in this test. PKT_DROPS_MAY_BE_EXPECTED is set\n");
    }
    4'b100X: {  // FAIL -- expecting pkt drops unless pkt_drop_may_be_expected is set
		if(!pkt_drop_may_be_expected)
                   be_msg.print(e_mesg_error, "niu_rxdma_pktchk", 
		       "collectStats", 
		       "expecting pkts drops in this test\n");
		else 
                   be_msg.print(e_mesg_info, "niu_rxdma_pktchk", 
		       "collectStats", 
		       "expecting pkts drops in this test but PKT_DROPS_MAY_BE_EXPECTED is set\n");

    }
    4'b101X,
    4'b110X,
    4'b1110: {   // FAIL -- rtl and env drop counts did not match
                if(!env_rtl_mismatch_expected)
                   be_msg.print(e_mesg_error, "niu_rxdma_pktchk", 
		       "collectStats", 
		       "env and rtl drop counts does not match\n");
                else
                   be_msg.print(e_mesg_info, "niu_rxdma_pktchk",
                       "collectStats",
                       "drop count mismatch between env and rtl found, but is expected by the TEST!\n");
    }
  } // case

  // Fatal error if there is any packet in the env which is not accounted for
  for(port_num=0;port_num<4;port_num++) {
    if(ports_active[port_num]) {
       TotalNoOfEntries += PacketScoreBoard[port_num].getNoOfEntries();
       be_msg.print(e_mesg_info, "niu_rxdma_pktchk", 
		    "collectStats", 
		    "PacketScoreBoard[%0d].getNoOfEntries:%0d\n",
		    port_num,PacketScoreBoard[port_num].getNoOfEntries());
    }
  }

  // rtl pkt drop better match with noOfEntries in score board
  if(TotalNoOfEntries != total_rtl_drop_count) {
   if(!env_rtl_mismatch_expected)
     be_msg.print(e_mesg_error, "niu_rxdma_pktchk", "collectStats", 
           	  "noOfEntries:%0d in PacketScoreBoard does not match with total_rtl_drop_cnt:%0d\n",
           	  TotalNoOfEntries, total_rtl_drop_count);
   else
     be_msg.print(e_mesg_info, "niu_rxdma_pktchk", "collectStats", 
           	  "noOfEntries:%0d in PacketScoreBoard does not match with total_rtl_drop_cnt:%0d, as expected by TEST\n",
           	  TotalNoOfEntries, total_rtl_drop_count);
  }

  for(port_num=0;port_num<4;port_num++) {
      if(ports_active[port_num]) {
         PacketScoreBoard[port_num].print_stats(*, 1);
      }
  }
  printf("============================ check_packet : collectStats ========================\n");

if (get_plus_arg(CHECK, "ENABLE_RX_EXIT_ROUTINE")) {
  // do exit check here
  for(port_num=0;port_num<4;port_num++) {
    if(ports_active[port_num]) {
       printf("CRxDmaPktChk: Doing RX Exit Routine for port %0d\n", port_num);
       rx_exit_routine(port_num);
    }
  }
}

}

task CRxDmaPktChk::RCR_FLUSH_START_pio_wr(bit [63:0] address, bit [63:0] data, integer dma) {
     gen_pio_drv.pio_wr(rdmc.rx_dma[dma].getPIOAddress(address,rdmc.rx_dma[dma].dis_pio_virt), data);
}

task CRxDmaPktChk::rx_exit_routine(integer mac_id) {

  bit [31:0] xmac_exp_status0,xmac_exp_status1;
  bit [31:0] bmac_exp_status2,bmac_exp_status3;
  rx_counters env_counters, rtl_counters;

  env_counters = new(mac_id);

  if (mac_id==0 || mac_id==1){
    env_counters.mac_crc_cntr=PacketScoreBoard[mac_id].no_of_packets_ext_l2_errors;
    env_counters.xmac_hist1_cntr=PacketScoreBoard[mac_id].hist1_count;
    env_counters.xmac_hist2_cntr=PacketScoreBoard[mac_id].hist2_count;
    env_counters.xmac_hist3_cntr=PacketScoreBoard[mac_id].hist3_count;
    env_counters.xmac_hist4_cntr=PacketScoreBoard[mac_id].hist4_count;
    env_counters.xmac_hist5_cntr=PacketScoreBoard[mac_id].hist5_count;
    env_counters.xmac_hist6_cntr=PacketScoreBoard[mac_id].hist6_count;
    env_counters.xmac_hist7_cntr=PacketScoreBoard[mac_id].hist7_count;
    env_counters.mac_mpszer_cntr=PacketScoreBoard[mac_id].max_pkt_err_count;
    env_counters.xmac_frag_cntr=PacketScoreBoard[mac_id].min_pkt_err_count;
    env_counters.xmac_byte_cntr=PacketScoreBoard[mac_id].xmac_byte_cnt;
    env_counters.xmac_mcast_cntr=PacketScoreBoard[mac_id].mcast_pkt_count;
    env_counters.xmac_bcast_cntr=PacketScoreBoard[mac_id].bcast_pkt_count;
    env_counters.mac_codevio_cntr=PacketScoreBoard[mac_id].code_viol_err_count;
    // Now, check the xmac status only if given the expected result
    if (get_plus_arg(CHECK, "EXPECTED_XMAC_EXIT_STATUS0="))
        xmac_exp_status0 = get_plus_arg(HNUM,"EXPECTED_XMAC_EXIT_STATUS0=");
    else
    	xmac_exp_status0 = 32'h00080001; // Expecting linkUpDown=1, FrameRcvd=1
    if (get_plus_arg(CHECK, "EXPECTED_XMAC_EXIT_STATUS1="))
        xmac_exp_status1 = get_plus_arg(HNUM,"EXPECTED_XMAC_EXIT_STATUS1=");
    else
    	xmac_exp_status1 = 32'h00080001; // Expecting linkUpDown=1, FrameRcvd=1
    if (mac_id==0)
      match_xmac_status(0, xmac_exp_status0);
    else if (mac_id==1)
      match_xmac_status(1, xmac_exp_status1);
  }
  else if (mac_id==2 || mac_id==3){
    env_counters.bmac_frame_cntr=PacketScoreBoard[mac_id].hist7_count;
    env_counters.bmac_alignerr_cntr=PacketScoreBoard[mac_id].bmac_align_err_count;
    env_counters.mac_crc_cntr=PacketScoreBoard[mac_id].no_of_packets_ext_l2_errors;
    env_counters.mac_codevio_cntr=PacketScoreBoard[mac_id].code_viol_err_count;
    env_counters.mac_mpszer_cntr=PacketScoreBoard[mac_id].max_pkt_err_count;
    // Now, check the bmac status only if given the expected result
    if (get_plus_arg(CHECK, "EXPECTED_BMAC_EXIT_STATUS2="))
        bmac_exp_status2 = get_plus_arg(HNUM,"EXPECTED_BMAC_EXIT_STATUS2=");
    else
        bmac_exp_status2 = 32'h1; // Expecting FrameRcvd=1
    if (get_plus_arg(CHECK, "EXPECTED_BMAC_EXIT_STATUS3="))
        bmac_exp_status3 = get_plus_arg(HNUM,"EXPECTED_BMAC_EXIT_STATUS3=");
    else
        bmac_exp_status3 = 32'h1; // Expecting FrameRcvd=1
    if (mac_id==2)
      match_bmac_status(2, bmac_exp_status2);
    else if (mac_id==3)
      match_bmac_status(3, bmac_exp_status3);
  }

  rtl_counters = rx_exit_tools.read_rx_rtl_cntrs(mac_id);
  if(mac_id==0 | mac_id==1)
    rtl_counters.xmac_hist7_cntr=niu_rx_test_util.xmac_hist7_cntr[mac_id]; // correct rtl value
  rx_exit_tools.match_rtl_env_cntrs(rtl_counters, env_counters);

}

task CRxDmaPktChk::match_xmac_status(integer mac_id, bit[31:0] status) {
bit [63:0] xmac_stat;
  niu_rx_test_util.XMAC_STATUS_pio_rd(mac_id, xmac_stat);
  if (xmac_stat[20:0] !== status[20:0])
   printf("ERROR xmac status for port %0d did not match in the exit check. Exp 0x%h, Got 0x%h\n",
		mac_id, status[20:0], xmac_stat[20:0]);
  else
   printf("EXIT-CHECK xmac status 0x%h for port %0d matched in the exit check.\n", status[20:0], mac_id);
}

task CRxDmaPktChk::match_bmac_status(integer mac_id, bit[31:0] status) {
bit [63:0] bmac_stat;
  niu_rx_test_util.BMAC_STATUS_pio_rd(mac_id, bmac_stat);
  if (bmac_stat[7:0] !== status[7:0])
   printf("ERROR bmac status for port %0d did not match in the exit check. Exp 0x%h, Got 0x%h\n",
		mac_id, status[7:0], bmac_stat[7:0]);
  else
   printf("EXIT-CHECK bmac status 0x%h for port %0d matched in the exit check.\n", status[7:0], mac_id);
}