// ========== Copyright Header Begin ==========================================
// 
// OpenSPARC T2 Processor File: pg_top_pp.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 "pcg_defines.vri"
#include "pcg_ports.vri"
#include "pack_db.vrh"
#include "flow_db.vrh"
#include "flow_db_tasks.vrh"
#include "mbox_class.vrh"
#include "get_mbox_id.vrh"

#include "cPgIf.vrh"

#include "pcg_token.vrh"
#include "cMesg.vrh"

extern Mesg            be_msg;


// extern pack_db_entry   pack_db[];
extern flow_db_entry   flow_db[];
extern mbox_class      mbox_id;
extern integer         quiet_on;
extern class           pg;
extern pg              ptr_to_first_pg;
extern pg              pack_gen[16];

extern "C" task InitpgSeed(integer seed);
extern "C" function bit[31:0] pgRand();

class CpgRandom {

  bit[31:0] seed;

  task new(integer i) {
    InitpgSeed(i);
  }
  function bit[7:0] nextdata() {
    bit [31:0] d;
    d = pgRand();
    nextdata = d[7:0];
  }
   
}

class pg {
  local integer	warning_count=0;	 
  local integer pg_done =0;
  local integer	error_count=0;		 
  bit [3:0]	port_type;		 
  local bit [63:0]	clock_counter;	 
  local integer	my_port;		 
  l3_class_desc	l3_class[61];		 
  l3_class_mask	l3_mask[40];		 
  local integer	pckt_num= -1;		 
  local integer	new_flow=0;		 
  local integer	order_seq=0;		 
  local integer	mb_q;			 
  local integer	pkt_gen_sync;			 
  local integer	queue_lock;		 
  static bit[19:0] pg_used_ports=0;	 
  bit [31:0] cfg_reg[CFG_LAST_ENTRY];	 
  local bit [15:0] ifedx_control;		 
  local bit [63:0] last_tx_time;		 
  local bit [63:0] prev_current_time=0;		  //hummer
  local integer port_speed ;		 
  local integer mac_speed ;		 
  // local event pkt_gen_lock ;
  integer pkt_gen_lock;
  local integer tx_done=0;		 
  local integer wait_send_fake;
  local integer rxdv_set=0;
  local event pg_random_event;

  integer	tx_err_start=-1;		 
  integer tx_err_len;			 

  integer debug_xgmii     = 0;
  integer debug_gmii      = 0;
  integer debug_mii       = 0;
  integer debug_fa        = 0;
  integer debug_mii_rx    = 0;
  integer debug_mii_tx    = 0;
  integer debug_xgmii_tx  = 1;
  integer debug_xgmii_rx  = 0;
  integer debug_gmii_rx   = 0;
  integer debug_rx        = 0;
  integer debug_dg        = 0;
  integer debug_db_in     = 0;
  integer debug_db_out    = 0;
  integer debug_checker   = 0;
  integer debug_out_token = 1;

  task config(integer what, bit [31:0] data) ;
  task print_warn() ;
  task print_err() ;
  task gen_buf( pack_db_entry pack_db, byte_array buf, var integer ptr ) ; 
  function byte_array new_gen_buf(pack_db_entry pack_db, var bit[31:0] pkt_fields[*]);
  task pkt_gen(   flow_desc flow, integer data_length, integer ttl, var CpgToken pgToken,  (	bit[63:0] options=0) );
  task pkt_auto_tx() ;
  task data_gen(integer type, integer seed, integer len, byte_array buf, var integer offset, bit[63:0] options,pg my_root, integer tagged, integer ifedx);
  task display_buf( byte_array buf, integer hwlen, (integer ifedx=0)) ;
  task display_class(byte_array buf, var integer ptr) ;
  task display_class_ipv6(byte_array buf, var integer ptr) ;
  task display_data(byte_array buf, var integer ptr, integer len) ;
  task display_id(bit [79:0] id) ;
  task display_db(pack_db_entry pack_db) ;
  task display_flow(integer flow_id) ;
  task send_packet(bit [3:0] ptype, byte_array buf, integer len, bit [63:0] options) ;
  task assert_col_tx (mii_def port_bind, bit [63:0] options) ;
  task assert_mii_err (mii_def port_bind ) ; 
  task send_packet_mii (mii_def port_bind, bit [3:0] ptype, byte_array buf, integer len, bit [63:0] options) ;
  task assert_gmii_err (gmii_def port_bind) ;
  task send_packet_gmii (gmii_def port_bind, bit [3:0] ptype, byte_array buf, integer len, bit [63:0] options) ;
  task assert_xgmii_err (xgmii_def port_bind) ;
  task send_packet_xgmii (xgmii_def port_bind,bit [3:0] ptype, byte_array buf, integer len, bit [63:0] options) ;
  task wait_clk(integer count) ;
  task count_clock() ;
  task wait_tx_clk(integer count) ;
  task wait_tx_clk_if ( mii_def port_bind, integer count) ;
  task wait_rx_clk(integer count) ;
  task wait_rx_clk_if ( mii_def port_bind, integer count) ;
  task config_tx (mii_def port_bind, integer mac_speed ) ; 
  task status() ;
  task new(integer my_porti, (bit [3:0] ptype=0)) ;
  task build_frame (integer itoken, pack_db_entry pack_db, byte_array buf, var integer len,(integer header_id=-1),(integer new_crc=0));

  function bit [15:0] ipv4_cksum( byte_array m, integer len) ;
  function bit [15:0] ip_datagram_chksum(byte_array d, integer start, integer len);
  function bit [15:0] tcp_chksum( pack_db_entry pack_db, byte_array d, integer start, integer len, integer pkt_type,integer chk_sum_location );
  function bit [31:0]  crc_gen(byte_array p, integer start, integer len) ;
  local function bit [31:0] crc32_add(bit [7:0] data, bit [31:0] crc) ;
  function integer check_option(bit [63:0] option, bit [63:0] flag) ;
  function bit [7:0] class_mask(integer funct, bit[7:0] a, bit[7:0] b) ;
  
  function bit[15:0] partial_cksum(byte_array packet, integer start_offset, integer pkt_len);

}



task pg::gen_buf( pack_db_entry pack_db, byte_array buf, var integer ptr ) {

  integer        len = -1;     
  integer        n;
  integer        he;           
  integer        flow_id;
  integer        ipv4_ptr;
  integer        ipv6_ptr;
  
  integer        tcp_hdr_start;
  integer        udp_hdr_start;
  integer        ip_hdr_start;
  integer        extra_tcp_hdr=0;
  integer        tcp_seg_len;
  
  bit [15:0]     tcp_length;
  bit [15:0]     udp_length;
  bit [15:0]     ip_length;
  bit [15:0]     ipv6_length;
  bit [15:0]     l2_length;
  bit [31:0]     tmp32, mask;
  bit [15:0]     tmp16 ;
  bit [15:0]     tmp16_ipck ;
  bit [15:0]     tmp16_tcpck ;
  bit [15:0]     tmp16_udpck ;  
  bit [15:0]     tmp16_ipdck ;
  bit [31:0]     isn_tmp;
  bit [47:0]     da_tmp;
  bit [95:0]     tcp_psu_hdr;
  bit [95:0]     udp_psu_hdr;
  bit [15:0]     ipv4_hdr[10];
  integer        tagged = 0;   
  bit [32:0]     addr;
  bit            dv;
  integer header_len_w_options;
  
// List of inputs to this function passed through a struct
  bit[47:0] l2_da,l2_sa;
  bit	[4:0]  frame_type;
  integer    tpid; 
  bit	[15:0]	tci;
  integer    frame_class;
  integer    data_length;
  integer    class_funct;
  integer frame_class_mask;
  integer    header_length;
  integer		ttl;
  bit [31:0]  spi;
  bit [7:0]   nxthdr;
  bit [7:0]   tos;
  integer type;
  bit	[128:0] src_ipv6_addr,dst_ipv6_addr;
  bit [31:0] src_ip_addr,dst_ip_addr;
  bit	[15:0] src_port,dst_port;
  bit [5:0] tcp_flags;
  bit [31:0] rcv_isn;
  bit [31:0] last_seqno;
  integer    data_type;
  integer    data_seed;
  integer gId;
  integer chk_sum_location;
  bit	[63:0]	options;
  bit[15:0] llc_length;
  integer LLC_HACK= 1;

  // Assign the inputs here TMP only
  flow_id = pack_db.flow.flow_no;
  l2_da = pack_db.dst_node.l2_addr;
  l2_sa = pack_db.src_node.l2_addr;
  frame_type = pack_db.frame.frame_type;
  tpid = pack_db.frame.tpid;
  tci = pack_db.src_node.tci;
  frame_class = pack_db.frame.frame_class;
  data_length  = pack_db.data_length;
  class_funct = pack_db.frame.class_funct;
  frame_class_mask = pack_db.frame.class_mask;

  header_length = pack_db.frame.header_length ;
  ttl = pack_db.ttl;
  spi = pack_db.src_node.spi;
  nxthdr = pack_db.src_node.nxthdr;
  tos = pack_db.src_node.tos;
  type = pack_db.frame.type;
  src_ipv6_addr = pack_db.src_node.ipv6_addr;
  dst_ipv6_addr = pack_db.dst_node.ipv6_addr;
  src_ip_addr = pack_db.src_node.ip_addr;
  dst_ip_addr = pack_db.dst_node.ip_addr;
  src_port  = pack_db.tup.src_tcp_udp_port;
  dst_port = pack_db.tup.dst_tcp_udp_port;
  tcp_flags = pack_db.fl_state.tcp_flags;
  rcv_isn = pack_db.rx_param.rcv_isn;
  //last_seqno = flow_db[flow_id].tx_param.last_seqno;

data_type  = pack_db.frame.data_type;
data_seed = pack_db.frame.data_seed;

  gId = pack_db.gId;
  options = pack_db.options;

  // DONE Assign the inputs here



  ptr=0;
   // L2 address
    '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
       buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = l2_da;
    '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
       buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = l2_sa;

      
      if( frame_type[2] ) { // 802.1Q 18 bytes long header 
        tagged = 1;
        if( tpid != -1) // 
          '{ buf.val[ptr++], buf.val[ptr++]} = tpid;		
        else
          '{ buf.val[ptr++], buf.val[ptr++]} = TPID_8021Q;	
          '{ buf.val[ptr++], buf.val[ptr++]} = tci;
      }



      
      if((frame_type[1] == 1) || (frame_type[4] == 1)) { // include ip header or tunneling options
        if( frame_type[0] == 1) { // if LLC SNAP  IP Header
          len = ptr;
          ptr = ptr+2;	
          if( check_option( pack_db.options, O_CUSTOM_LS) ) {
            tmp32 = cfg_reg[CFG_CUST_LS];
            '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++]} = tmp32[23:0];
          } else
          '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++]} = LLC_SNAP;
           buf.val[ptr++] = H_UNDEF;
           buf.val[ptr++] = H_UNDEF;
           buf.val[ptr++] = H_UNDEF;
          } else {
           len = - 1;	
        }
        
        if( frame_type[3] == 1 && frame_class < CL_TCP_OPT  ) // IPV6 Header
          frame_class += DELTA;
        
        if( frame_type[3] == 0 ) {  // IPV4 Header

          if ( (frame_type[0] == 1 ) &&  (frame_type[2] == 1 )) { // LLC_SNAP and 802.1Q Tagged 
            l2_length = 26;
          } else if (frame_type[2] == 1 ) { // ONLY  802.1Q Tagged
            l2_length = 18;
          } else if  (frame_type[0] == 1 ) { // ONLY LLC_SNAP
            l2_length = 22;
          } else{ // NONE of the above 
            l2_length = 14;
          }

          ip_length = data_length -4 -(l2_length) ;
	


          pack_db.ipp.ip_hdr_len = ip_length;
          printf("pg::gen_buf The IP length is %0h , ptr - %d \n", ip_length,ptr);

          for( n=0; n<2; n++) {
            buf.val[ptr++] = class_mask(  class_funct, l3_class[frame_class].val[n], l3_mask[frame_class_mask].val[n]  );
	    }
          // add header option field here
	    buf.val[ptr] = class_mask(  class_funct, l3_class[frame_class].val[2],
                                        l3_mask[frame_class_mask].val[2]  );
           if((buf.val[ptr] & 8'h40) == 8'h40) { // if IPV4
	       buf.val[ptr++]  = 8'h40 | (  header_length & 4'hf) ;
            }

          buf.val[ptr++] = tos; 
          buf.val[ptr++] = ip_length[15:8];
          buf.val[ptr++] = ip_length[7:0];
          
          for( n=6; n<12; n++) {
	  // Fill in rest of the header bytes
            buf.val[ptr++] = class_mask(  class_funct, l3_class[frame_class].val[n],
                                        l3_mask[frame_class_mask].val[n]  );
	 }

	// This appears to be programmed by the user to override the automatically generated type field 
         if(type != -1)	 // This should be moved up? ....
            '{buf.val[ptr-14], buf.val[ptr-13]} = type;

         // This should be moved up? ....
         if(ttl != -1)	buf.val[ptr-2] = ttl; 

            
            
            
            '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000; // 0s for header checksum
            
         '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = src_ip_addr;
         '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = dst_ip_addr;

	  // Add options here
     
	  header_len_w_options = ( (buf.val[ptr -20 /*14*/ ] & 8'h40 )== 8'h40) ?   header_length : 0;
	  printf(" DEBUG-- header_len_w_options - %d buf value - %x  \n",header_len_w_options,buf.val[ptr -20 /*14*/ ] );

          for(n=0;n< (4*header_len_w_options - 20); n++) {
	    buf.val[ptr++] = 8'ha0 + n;
	   // printf(" DEBUG-- ptr - %d val - %x \n",ptr,buf.val[ptr -1]);
          }

         tmp16_ipck = ipv4_cksum(buf,ptr);

                
	// Write back computed checksum
        '{buf.val[ptr-10 - (4*header_len_w_options - 20) ],buf.val[ptr-9 - (4*header_len_w_options - 20) ]} = tmp16_ipck; 

         if( frame_class == CL_IP_SEC_ESP) {
             '{buf.val[ptr++],buf.val[ptr++],buf.val[ptr++],buf.val[ptr++]} = spi;
             '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
             '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
             '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
             '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
         }
         if( frame_class == CL_IP_SEC_AH) {
             //buf.val[ptr++] = 8'h06;//Assumes TCP 
             buf.val[ptr++] = nxthdr;
             buf.val[ptr++] = 8'h03;//LenHdr-2 (32bit Words) 
             '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
             '{buf.val[ptr++],buf.val[ptr++],buf.val[ptr++],buf.val[ptr++]} = spi;
             '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
             '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
         }
        }   // endif IPV4 packet
        else if ( frame_type[3] == 1 ) {  // IPV6 Packet
         // printf("pcg_fa.vr: Bulding IPv6 Packet \n");

          if( (frame_type[2] == 1 ) && (frame_type[0] == 1)) {
            l2_length = 26;
          } else if  (frame_type[2] == 1 ) {  
            l2_length = 18;
          } else if  (frame_type[0] == 1 ) {
            l2_length = 22;
          } else{
            l2_length = 14;
          }
                    ipv6_length = data_length - 40 -4 -(l2_length);

          pack_db.ipp.ip_hdr_len = ipv6_length;

          printf("pg::gen_buf The val of  ip_length is %0d\n",ipv6_length);
          
          for( n=0; n<2; n++)
            buf.val[ptr++] = class_mask( class_funct,
                                        l3_class[frame_class].val[n],
                                        l3_mask[frame_class_mask].val[n] );

          buf.val[ptr++] = {4'h6,tos[7:4]};
          buf.val[ptr++] = {tos[3:0],4'h0};

          for( n=4; n<6; n++)
            buf.val[ptr++] = class_mask( class_funct,
                                        l3_class[frame_class].val[n],
                                        l3_mask[frame_class_mask].val[n] );



          buf.val[ptr++] = ipv6_length[15:8];
          buf.val[ptr++] = ipv6_length[7:0];

          for( n=8; n<10; n++)
            buf.val[ptr++] = class_mask( class_funct,
                                        l3_class[frame_class].val[n],
                                        l3_mask[frame_class_mask].val[n] );
          
          if(type != -1)
            '{buf.val[ptr-10], buf.val[ptr-9]} = type;

            
            if(ttl != -1)	buf.val[ptr-1] = ttl; 

            
            '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
              buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
              buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
              buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = src_ipv6_addr;

              '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
                buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
                buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
                buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = dst_ipv6_addr;

                if( frame_class == CL_IP_V6_SEC_ESP) {
                  
                  '{buf.val[ptr++],buf.val[ptr++],buf.val[ptr++],buf.val[ptr++]} = spi;
                  
                  '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
                  '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
                  '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
                  '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
                }

                if( frame_class == CL_IP_V6_SEC_AH) {
                  
                  buf.val[ptr++] = 8'h06;//Assumes TCP 
                  buf.val[ptr++] = 8'h03;//LenHdr-2 (32bit Words) 
                  '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
                  '{buf.val[ptr++],buf.val[ptr++],buf.val[ptr++],buf.val[ptr++]} = spi;
                  
                  '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
                  '{buf.val[ptr++],buf.val[ptr++]} = 16'h0000;
                }
        }    // endif IPV6 

        printf("pg::gen_buf : Frame_class: %d frame_type - %x \n"  , frame_class,frame_type );

        if( frame_class == CL_UDP           | frame_class == CL_UDP_OPT       | 
           frame_class == CL_UDP_FRAG      |   frame_class == CL_UDP_IP_V6     |
           frame_class == CL_UDP_OPT_IP_V6 | frame_class == CL_UDP_FRAG_IP_V6 ) {
          

          if ( frame_type[3] == 1 ) { // IPV6
            udp_length = data_length - 40 -4 -(l2_length);           }
          if( frame_type[3] == 0 ) { // IPV4
                        udp_length = data_length - (4*header_len_w_options)  -4 -(l2_length); 	    // printf("DEBUG udp length - %d \n",udp_length); 
          }

          udp_psu_hdr = {src_ip_addr, dst_ip_addr, 8'h00,8'h17,udp_length};
          udp_hdr_start = ptr ;
          pack_db.psu_hdr= (udp_psu_hdr);
          
          '{ buf.val[ptr++], buf.val[ptr++] } = src_port;
          '{ buf.val[ptr++], buf.val[ptr++] } = dst_port;


          buf.val[ptr++] = udp_length[15:8];
          buf.val[ptr++] = udp_length[7:0];

          '{ buf.val[ptr++], buf.val[ptr++] } = 16'h00;

        }/*endif CL_UDP*/ 
           else if ( frame_class == CL_TCP       | frame_class == CL_TCP_OPT       | 
                     frame_class == CL_TCP_FRAG      | frame_class == CL_TCP_IP_V6     |
                     frame_class == CL_TCP_OPT_IP_V6 | frame_class == CL_TCP_FRAG_IP_V6  ) {
          //printf("pcg_fa.vr: Adding TCP Header  \n");   

          tcp_psu_hdr = {src_ip_addr, dst_ip_addr, 8'h00,8'h06,16'h0000};
          pack_db.psu_hdr= (tcp_psu_hdr);
          tcp_hdr_start = ptr ;

          '{ buf.val[ptr++], buf.val[ptr++] } = src_port;
          '{ buf.val[ptr++], buf.val[ptr++] } = dst_port;

          if( tcp_flags == 2'h2 ) {  
            '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = rcv_isn;
          } else {
            '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } =  flow_db[flow_id].tx_param.last_seqno;
              flow_db[flow_id].rx_param.rcv_isn = flow_db[flow_id].tx_param.last_seqno;
          }

          if(frame_class != CL_TCP_OPT & frame_class != CL_TCP_OPT_IP_V6)
          { cfg_reg[CFG_TCP_LEN] = 4'b0101; }
          '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = cfg_reg[CFG_TCP_ACK];
           tmp32[15:0] = {cfg_reg[CFG_TCP_LEN], 6'b000000, tcp_flags} ;
          '{ buf.val[ptr++], buf.val[ptr++] } = tmp32[15:0];
           tmp32 = cfg_reg[CFG_TCP_WIN];
          '{ buf.val[ptr++], buf.val[ptr++] } = tmp32[15:0];
            
          '{ buf.val[ptr++], buf.val[ptr++] } = 16'h00;
           tmp32 = cfg_reg[CFG_TCP_URG];
          '{ buf.val[ptr++], buf.val[ptr++] } = tmp32[15:0];

            //TCP option
            if ( (cfg_reg[CFG_TCP_LEN] ) > 5 ) {
              extra_tcp_hdr = (cfg_reg[CFG_TCP_LEN] - 5 ) * 4;  
              pack_db.mac.extra_tcp_hdr = extra_tcp_hdr;
              for ( n =0; n< extra_tcp_hdr; n++) { 
                buf.val[ptr++] = 8'ha5; 
              }
            } else { 
              extra_tcp_hdr = 0; 
              pack_db.mac.extra_tcp_hdr = extra_tcp_hdr;
            }
        }    // endif CL_TCP*
      }  // endif include ip header or tunneling option
      else {
        printf("pg::gen_buf : No L3 header selected\n");
        if( frame_type[0] == 1) { // LLC_SNAP
          len = ptr;	
          ptr = ptr+2;
          if( check_option( pack_db.options, O_CUSTOM_LS) ) {
            tmp32 = cfg_reg[CFG_CUST_LS];
            '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++]} = tmp32[23:0];
          } else
          '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++]} = LLC_SNAP;
          buf.val[ptr++] = H_UNDEF;
          buf.val[ptr++] = H_UNDEF;
          buf.val[ptr++] = H_UNDEF;
         '{buf.val[ptr++],buf.val[ptr++]} = 16'h0008;
        } else { 
          len = ptr;	
          ptr = ptr+2;
        }
      } // endif else of include ip header 

      he = ptr-1; // header length
      tcp_length = data_length -he -4;
      tcp_seg_len = data_length - ptr - 4;

      if(data_type != DAT_FC_PAUSE)
        '{buf.val[ptr++], buf.val[ptr++]} = gId;	

      if(LLC_HACK & ( (pack_db.frame.frame_type== 5'h3 )| (pack_db.frame.frame_type== 5'h7) )) {
         printf("gen_buf LLC_HACK!!! data_len - %d \n",pack_db.data_length);
          if(pack_db.flow.frame.frame_type== 5'h3) {
            llc_length = pack_db.data_length - 4/*CRC*/ - 12/*L2HEADERS*/ -2/*Type/Length*/ ;
            buf.val[12] = llc_length[15:8];
            buf.val[13] = llc_length[7:0];
	  }
          else {
            llc_length = pack_db.data_length - 4/*CRC*/ - 12/*L2HEADERS*/ -4/*VLAN ID*/  -2/*Type/Length*/ ;
            buf.val[16] = llc_length[15:8];
            buf.val[17] = llc_length[7:0];
	  }

        }




     /* Generate data payload */
     data_gen(data_type, data_seed, data_length, buf, ptr, pack_db.options, this, tagged, INTER_FEDX);
     // printf("DEBUG--- After data_gen len - %d \n",len);
     // printf("DEBUG---type -  %d %d %d \n",type,ptr, he);

     // Add L2 Length here
     if( len > 0 ) {
       if( check_option( pack_db.options, O_FRM_LEN_ERR1) )
          '{buf.val[len], buf.val[len+1] } = cfg_reg[CFG_FRM_LEN];
        else {
           if(type == -1) {
              '{buf.val[len], buf.val[len+1] } = ptr - (he+1);
            } else
            '{buf.val[len], buf.val[len+1] } = type;	
          }
      }

     if( frame_class == CL_TCP | frame_class == CL_TCP_OPT | 
         frame_class == CL_TCP_FRAG | frame_class == CL_TCP_IP_V6 |
         frame_class == CL_TCP_OPT_IP_V6 | frame_class == CL_TCP_FRAG_IP_V6  ) {
          
	// Calculate TCP checksum
          flow_db[flow_id].data_length = tcp_seg_len;
          flow_db[flow_id].tx_param.last_seqno = (flow_db[flow_id].rx_param.rcv_isn) + flow_db[flow_id].data_length;

          chk_sum_location = he-extra_tcp_hdr-3;

          tmp16_tcpck = tcp_chksum(pack_db,buf,tcp_hdr_start,ptr,1, chk_sum_location );
	  printf("gen_buf-- tcp_chksum - %x tcp_hdr_start - %d chk_sum_location - %d \n",tmp16_tcpck,tcp_hdr_start,chk_sum_location);

          if( check_option( pack_db.options, O_TCPCKSUM_ERR) ){
            tmp16_tcpck = tmp16_tcpck ^ cfg_reg[CFG_TCPCKSUM_MASK];
          } 
          '{buf.val[he-extra_tcp_hdr-3],buf.val[he-extra_tcp_hdr-2]} = tmp16_tcpck; 
          pack_db.ipp.tcp_cksum = tmp16_tcpck;
        } // C

        if(frame_class == CL_UDP | frame_class == CL_UDP_OPT |
           frame_class == CL_UDP_FRAG | frame_class == CL_UDP_IP_V6 |
           frame_class == CL_UDP_OPT_IP_V6 | frame_class == CL_UDP_FRAG_IP_V6 ) {
	// Calculate UDP checksum

          chk_sum_location = he -1;
          tmp16_udpck = tcp_chksum(pack_db,buf,udp_hdr_start,ptr,0,chk_sum_location);
	  printf("gen_buf-- udp_chksum - %x udp_hdr_start - %d chk_sum_location - %d \n",tmp16_udpck,udp_hdr_start,chk_sum_location);

          '{buf.val[he-1],buf.val[he-0]} = tmp16_udpck;
        }

        ip_hdr_start = l2_length ;

        if (frame_type[1] == 1) { // IPV4 
          tmp16_ipdck =ip_datagram_chksum(buf,ip_hdr_start,ptr);
          pack_db.ipp.ip_datagram_cksum = tmp16_ipdck;
        }

	pack_db.add_header(buf,0,he);	 

      if(LLC_HACK & ( (pack_db.frame.frame_type== 5'h3 )| (pack_db.frame.frame_type== 5'h7) )) {
         printf("LLC_HACK!!! \n");
          if(pack_db.flow.frame.frame_type== 5'h3) {
            llc_length = pack_db.data_length - 4/*CRC*/ - 12/*L2HEADERS*/ -2/*Type/Length*/ ;
            buf.val[12] = llc_length[15:8];
            buf.val[13] = llc_length[7:0];
	  }
          else {
            llc_length = pack_db.data_length - 4/*CRC*/ - 12/*L2HEADERS*/ -4/*VLAN ID*/  -2/*Type/Length*/ ;
            buf.val[16] = llc_length[15:8];
            buf.val[17] = llc_length[7:0];
	  }
        }

        tmp32 = crc_gen(buf, 0, ptr);

	if( check_option( pack_db.options, O_CRC_ERR) )	tmp32 = tmp32 ^ cfg_reg[CFG_CRC_MASK];
	'{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = tmp32;

	pack_db.pack_crc = tmp32;
	pack_db.frame_len = ptr;
	// printf(" end of  gen_buf - ptr -   %d \n",ptr);
}  



function bit [15:0] pg::ipv4_cksum( byte_array m, integer len){

  integer i,j;
  bit [15:0] tmp[];
  bit [31:0] cksum;

  j = len -20;
  cksum = 0;

  printf ("pg::ipv4_cksum: The val of len is %d\n",len);
  for (  i=j; i< (j+20); i=i+2) {
    tmp[i] = {m.val[i], m.val[(i+1)]};
    // printf("The val of buffer is %0h\n",tmp[i]);
    cksum = cksum + tmp[i];

    if (cksum[16] ==1) {
      cksum =  cksum[15:0] + 1;
    }
  }


  ipv4_cksum = ~cksum;
  printf(" pg::ipv4_cksum: chksum - %x \n",ipv4_cksum);

}

function bit [15:0] pg::ip_datagram_chksum(  byte_array d, \
                                           integer start, integer len){

  integer i,j,k;
  bit [15:0] tmp[];
  bit [31:0] ipsum;
  integer ip_len;
  integer pad;

  ip_len =  len - start;

  ipsum  =  0;


  printf ("pg::ip_datagram_chksum: The val of ip hdr start and len is %0d and %0d\n", start,len);

  if (ip_len %2 != 0) {
    pad =1;
  }else {
    pad  = 0;
  }

  for (i=start;i<len+pad;i=i+2) {
    d.val[len]  =  0;
    tmp[i] = {d.val[i],d.val[i+1]}; 
    ipsum = ipsum  +  tmp[i];
    //printf("The val of buffer is %0h\n",tmp[i]);
    //printf("The val of sum of payld is is %0h\n",ipsum);

    if (ipsum[16] ==1) {
      ipsum =  ipsum[15:0] + 1;
    }
  }
  ip_datagram_chksum = ~ipsum;

  printf("pg::ip_datagram_chksum: The val of IP Datagram Checksum is %0h \n",ip_datagram_chksum);

}


function bit [15:0] pg::tcp_chksum( pack_db_entry pack_db, byte_array d, integer start, integer len, integer pkt_type, integer chk_sum_location ){

  integer i,j,k;
  bit [15:0] tmp[];
  bit [15:0] tmp0[];
  bit [15:0] tmp1[];
  bit [15:0] sum_hdr;
  bit [31:0] ip_src_sum;
  bit [31:0] ip_dst_sum;
  bit [127:0] ipv6_src;
  bit [127:0] ipv6_dst;
  bit [31:0] tcp_proto_sum;
  bit [95:0] psu_hdr;
  bit [31:0] sum;
  integer tcp_len;
  integer pad;

  integer partial_chksum;


   partial_chksum = pack_db.flow.partial_chksum;
 
   if(partial_chksum) {
    d.val[chk_sum_location] = pack_db.flow.psu_hdr[0];
    d.val[chk_sum_location + 1] = pack_db.flow.psu_hdr[1];
    printf("  pg::tcp_chksum partial checksum location - %d hdr[0]- %x hdr[1] - %x \n",chk_sum_location,pack_db.flow.psu_hdr[0],pack_db.flow.psu_hdr[1]);
    sum  =  partial_cksum( d,start,len );
    printf("  pg::tcp_chksum partial checksum - %x \n",sum);
   } else {

      tcp_len =  len - start;
      sum  =  0;
      printf("pg::tcp_chksum start - %d len - %d \n",start,len);

      if (pack_db.frame.frame_type[3] == 0){
        psu_hdr = {pack_db.src_node.ip_addr, pack_db.dst_node.ip_addr, 8'h00,8'h06,16'h0000};
    // printf("The val of psu header is %0h\n",psu_hdr);
     }
     if (tcp_len %2 != 0) {
       pad =1;
     }else {
      pad  = 0;
     }

     for (i=start;i<len+pad;i=i+2) {
       d.val[len]  =  0;
       tmp[i] = {d.val[i],d.val[i+1]}; 
       sum = sum  +  tmp[i];
       if (sum[16] ==1) {
        sum =  sum[15:0] + 1;
       }
     }
     if (pack_db.frame.frame_type[3] == 0){
       ip_src_sum =  pack_db.src_node.ip_addr[15:0] + pack_db.src_node.ip_addr[31:16];
     if (ip_src_sum[16] ==1) {
      ip_src_sum =  ip_src_sum[15:0] + 1;
    }
    sum = sum + ip_src_sum;
    if (sum[16] ==1) {
      sum =  sum[15:0] + 1;
    }
    ip_dst_sum = pack_db.dst_node.ip_addr[15:0] + pack_db.dst_node.ip_addr[31:16];  
    if (ip_dst_sum[16] ==1) {
      ip_dst_sum =  ip_dst_sum[15:0] + 1;
    }
    sum = sum + ip_dst_sum;
    if (sum[16] ==1) {
      sum =  sum[15:0] + 1;
    }
    if(pkt_type == 1)
       {
        tcp_proto_sum  = 16'h0006 +  tcp_len;
       }
    else
       {
        tcp_proto_sum  = 16'h0011 +  tcp_len;
       }

    if (tcp_proto_sum[16] ==1) {
      tcp_proto_sum =  tcp_proto_sum[15:0] + 1;
    }

    sum = sum + tcp_proto_sum;

    if (sum[16] ==1) {
      sum =  sum[15:0] + 1;

    }
    //printf("The val of sum of payld & tcp_proto is is %0h\n",sum);

  }

  if (pack_db.frame.frame_type[3] == 1){


    ipv6_src =  pack_db.src_node.ipv6_addr;
    ipv6_dst =  pack_db.dst_node.ipv6_addr;

    //printf("The val of ipv6 src  is %0h\n", ipv6_src );



    j = 127;

    for ( k= 0 ; k < 8; k++ ) { 
      tmp0[k] = {ipv6_src[j:j-7], ipv6_src[j-8:j-15]};   
      //printf("The val of src buffer is %0h\n",tmp0[k]);
      sum = sum + tmp0[k]; 
      if (sum[16] ==1) {
        sum =  sum[15:0] + 1;

      }
      j = j -16 ;

    }

    //printf("The val of sum at src  is %0h\n", sum);
    j = 127;

    for ( k= 0 ; k < 8; k++ ) { 
      tmp1[k] = {ipv6_dst[j:j-7], ipv6_dst[j-8:j-15]};   
      //printf("The val of dst buffer is %0h\n",tmp1[k]);
      sum = sum + tmp1[k]; 
      if (sum[16] ==1) {
        sum =  sum[15:0] + 1;

      }

      j = j -16 ;
    }

    //printf("The val of sum at dst  is %0h\n", sum);


    if (pkt_type == 1) {
      tcp_proto_sum  = 16'h0006 + tcp_len;
    } else { 
      tcp_proto_sum  = 16'h0011 + tcp_len;
    }
    

    if (tcp_proto_sum[16] ==1) {
      tcp_proto_sum =  tcp_proto_sum[15:0] + 1;
    }

    sum = sum + tcp_proto_sum;

    if (sum[16] ==1) {
      sum =  sum[15:0] + 1;
    }
  }

  
  // printf("The val of start and len are %0d and %0d\n",start,len);

  // printf("The FINAL val of sum   is %0h\n", sum);

  }
  tcp_chksum = ~sum;

}

task pg::pkt_gen( flow_desc flow, integer data_length, integer ttl, var CpgToken pgToken, 
                 (bit[63:0] options=0) ){

  integer time_out = 0;
  
  integer current_flow_num;
  integer flow_id;
  pack_db_entry pack_db;
  integer id;
  integer token;
  byte_array tmpbuf;
  printf("pg::pkt_gen called Time - %d \n", {get_time(HI),get_time(LO)});
  semaphore_get(WAIT,pkt_gen_lock,1);
  printf("pg::pkt_gen after sem called Time - %d \n", {get_time(HI),get_time(LO)});

  // sync(ALL,pkt_gen_lock);
  // trigger(OFF,pkt_gen_lock);

  current_flow_num = flow.flow_no; 

  

  if(my_port > 15 ) {
    printf("pg::pkt_gen: WARNING: PG: Port %0d is invalid (only used to satisfy fflp testsuite).\n",my_port);
    printf("pg::pkt_gen:              No action is taken.\n");
    return;
  }

  pckt_num++;
  token = pckt_num; // TOADS

  if (flow.fl_state.tcp_flags == 6'h02)
    new_flow++;


  case({	check_option(options, O_ORDER_START),
    check_option(options, O_ORDER_CONT),
    check_option(options, O_ORDER_END)	}) {
    3'b100:	order_seq = 0;
    3'b010:	order_seq++;
    3'b001:	order_seq++;
  }

  if(flow.src_node.src_port[my_port] != 1) {
    print_warn();
    printf("pg::pkt_gen PG: Specified src_node may not be used as source for this port. Continuing anyway ...\n");
  }


  pack_db = new(pckt_num ); 
  pack_db.preamble_cnt = flow.preamble_cnt;
  pack_db.sfd = flow.sfd;
  // printf("DEBUG pack_db.options - %x preamble_cnt - %d sfd - %d \n",pack_db.options,pack_db.preamble_cnt,pack_db.sfd);

  pg_done = 0;
  id = pack_db.add(my_port, flow, flow.frame, flow.src_node, flow.dst_node, flow.tup, flow.rx_param, flow.tx_param, flow.fl_state, data_length,ttl, options | flow.options , order_seq,
                   pckt_num, ifedx_control);
  pack_db.port_type = port_type;
  if( pack_db.fl_state.tcp_flags == 2'h2 ) {
    // TOADS
    flow_db_add_entry( my_port, data_length, flow, flow.tup, flow.rx_param, flow.tx_param, flow.fl_state, options, current_flow_num );
  }
  if(debug_db_in)	display_db(pack_db);
  wait_send_fake=0;

  
  // TOADS---
  printf("Before  mailbox_put mb_q - time - %d \n",{get_time(HI),get_time(LO)});

  mailbox_put(mb_q, pack_db); 

  printf("pg::pkt_gen: Waiting for packet to go out ...(port type: %h), token# %0d\n",port_type, token);
  printf("pg::pkt_gen: Waiting for packet to go out wait_send_fake - %d Time - %d \n",wait_send_fake,{get_time(HI),get_time(LO)});
  printf("pg::pkt_gen: Waiting for packet to go oui options  - %d Time - %d \n", pack_db.options,{get_time(HI),get_time(LO)});
  

  if( check_option( pack_db.options, O_WAIT_SEND_FAKE) ) {
    while(wait_send_fake==0)	@(posedge CLOCK);
  }



  if( check_option( pack_db.options, O_WAIT_SEND) ) {

    fork
      while(time_out<10000) {
        wait_rx_clk(1);
        time_out++;
      }

      while(pg_done!=1)	@(posedge CLOCK);
    join any
    printf("pg::pkt_gen: before terminate timeout - %d pg_done - %d \n",time_out,pg_done);

    terminate;


    if(pg_done!=1) {
      pg_done=1;
      print_warn();
      printf("PG: Timed out waiting for done bit (waited %0d cycles)...\n",time_out);
      printf("    This only happens with fake ports when we wait for someone\n");
      printf("    to acknowladge that the packet was processed (Port: %0d).\n",my_port);
      printf("    Token: %0d, Time: %0d\n",token,{get_time(HI),get_time(LO)});
    }

  }

  
  pgToken = new (id);
  pgToken.pack_db = new pack_db;
  pgToken.port_id = my_port;
  mailbox_get(WAIT,pkt_gen_sync,tmpbuf);
  pgToken.buf = new tmpbuf;
  // display_buf(pgToken.buf,data_length);

  // printf(" in pkt_gen -- length - %d \n", pack_db.header_len[0]);
  printf("pg::pkt_gen: Waiting End of pkt_gen !!! Time - %d \n",{get_time(HI),get_time(LO)});
  // trigger(ON,pkt_gen_lock);
  semaphore_put(pkt_gen_lock,1);
}

function byte_array pg::new_gen_buf(pack_db_entry pack_db, var bit[31:0] pkt_fields[*]){

   bit [7:0] payload[*];
   integer i,size;
   CPgIf cPg;
   integer len;
   byte_array buf;

   cPg = new();
   len = pack_db.data_length;
   printf("byte_array pg::new_gen_buf function id - %d  !! Time - %d \n",my_port,{get_time(HI),get_time(LO)});

    cPg.genPacket(0,len, pack_db.flow, payload,pkt_fields);
    buf = new();
    for( i = 0; i < len + pack_db.flow.frame.l2_pad_length;i++) {
       buf.val[i] = payload[i] & 8'hff;
       // printf(" PKT buf - %x index - %d \n", buf.val[i],i);
     }
 new_gen_buf = buf;
}
task pg::pkt_auto_tx() {
  integer		len;		 
  byte_array	buf;		 
  integer		token;		 
  pack_db_entry pack_db;
  event lock_send_packet;
  CpgToken pgToken;
  byte_array tmpbuf;
  bit[31:0] pkt_fields[*] ;

  integer i;

  trigger(ON,lock_send_packet);


  while(1) {

    sync(ALL,lock_send_packet);
    trigger(OFF,lock_send_packet);
   printf(" Before mailbox_get mb_q Time - %d \n",{get_time(HI),get_time(LO)} );

    mailbox_get(WAIT, mb_q, pack_db);
   printf(" After mailbox_get mb_q Time - %d \n",{get_time(HI),get_time(LO)} );
    if(debug_db_out)	display_db(pack_db);

    buf = new();
    // gen_buf( pack_db, buf, len );
     len = pack_db.data_length + pack_db.flow.frame.l2_pad_length;
     buf = new_gen_buf(pack_db,pkt_fields);

    wait_send_fake=1;

    pgToken = new (pack_db.gId);
    pgToken.pack_db = new pack_db;
    pgToken.port_id = my_port;
    pgToken.pkt_fields = new[SIZE_OF_PKT_FIELDS];
    for(i=0;i<SIZE_OF_PKT_FIELDS;i++) {
     pgToken.pkt_fields[i] = pkt_fields[i];
    }
   
    tmpbuf = new buf;
    mailbox_put(pkt_gen_sync,tmpbuf);



    if( !check_option( pack_db.options, O_NO_OUT_TOKEN) ) {
      if(debug_out_token)
      printf("pg::pkt_auto_tx: INFO: PG[%0d]: Sending token (%0d) to outgoing mailbox. (Time: %d)\n", my_port, token, {get_time(HI),get_time(LO)} );
      mailbox_put(mbox_id.pg_mb[my_port], pgToken); 
    }


    printf("pg::pkt_auto_tx:pg[%0d]: Transmitting packet ...\n",my_port);
    // printf("options fake out: %d\n",check_option( pack_db.options, O_FAKE_OUT) );
    if( !(check_option( pack_db.options, O_FAKE_OUT )) & !port_type[2] ) {
      printf("pg::pkt_auto_tx:INFO: PG[%0d]: Sending out packet token:%0d at time %0d \n",my_port,pack_db.gId , {get_time(HI),get_time(LO)}); 
// HACK HACK HACK
      
     if( check_option(pack_db.options, O_PREAMB_ERR) )     cfg_reg[CFG_PRAMB_CNT] = pack_db.preamble_cnt;
     if( check_option(pack_db.options, O_SFD_ERR) )        cfg_reg[CFG_SFD_TOKEN] = pack_db.sfd;
  // printf("DEBUG pack_db.options - %x preamble_cnt - %d sfd - %d \n",pack_db.options,cfg_reg[CFG_PRAMB_CNT],cfg_reg[CFG_SFD_TOKEN]);


      send_packet(port_type, buf, len, pack_db.options);
      pg_done = 1;
      
      // printf("pg::pkt_auto_tx:INFO: PG[%0d]: Packet token %0d sent done at time=%0d  \n",my_port, token,{get_time(HI),get_time(LO)});
    }
    printf("pg::pkt_auto_tx:pg[%0d]: Done Transmitting packet ...\n",my_port);
    trigger(ON,lock_send_packet);
  }
}


task pg::build_frame(integer itoken,pack_db_entry pack_db, byte_array buf, var integer len,(integer header_id=-1),(integer new_crc=0)) {
  integer n;
  integer ptr=0;
  integer tagged = 0;
  integer my_port, org_port;
  bit [31:0] tmp32;
  integer data_len, header_len;
  integer debug = 0;
  integer token;
  integer adj_len=0;
  integer min,max;
  bit     [15:0] tx_status;
  integer LLC_HACK = 1;
  bit[15:0] llc_length;

  tmp32 = itoken;
  token = tmp32[25:0];

  if(debug)
    printf("DEBUG: build_frame: Started Build-Frame. (Input: Token: %0d, Len: %0d Hdr: %0d, NewCRC: %0d Port: %0d)\n", 
           token,len,header_id,new_crc,my_port);
  // display_db(pack_db);
  // printf(" data_len from build_frame - %d \n",pack_db.data_length);

  my_port  = pack_db.org_port;
  org_port = pack_db.org_port;
  if(header_id != -1)	my_port = header_id;



  if(debug)	printf("DEBUG: build_frame: (1)ptr: %0d\n",ptr);
  // printf(" in build frame header_d - %d \n",header_id);

  if(header_id==-1) {
    header_len = pack_db.header_len[ pack_db.use_hdr ];
    // printf(" in build frame header_len - %d use_header - %d \n",header_len,pack_db.use_hdr);

    for(n=0;n< header_len ;n++)
      buf.val[ptr++] = pack_db.header[ pack_db.use_hdr ].val[n];
  } else {

#define out_use_header pack_db.out_header[header_id].use_header

    if(  assoc_index(CHECK,pack_db.out_header,header_id) &
       assoc_index(CHECK,pack_db.out_header[header_id].header, out_use_header) )  {

      header_len = pack_db.out_header[header_id].header_len[ out_use_header ];
      // printf(" in build frame header_len - %d \n",header_len,out_use_header);

      for(n=0; n < header_len ; n++)
        buf.val[ptr++] =pack_db.out_header[header_id].header[out_use_header].val[n];
    } else {
      printf("pg::build_frame: ERROR: PG LIB: build_frame: out header invalid. (Token:%0d, Out header id: %0d).\n",
             token,header_id);
      len = 0;
      buf = null;
      return;
    }
  }

  if(debug)  printf("DEBUG: build_frame: header_len: %0d\n",header_len);
  if(debug)	printf("DEBUG: build_frame: (2)ptr: %0d\n",ptr);


  if(pack_db.frame.data_type != DAT_FC_PAUSE)
    '{buf.val[ptr++], buf.val[ptr++]} = token;  // Store token in payload


    if(pack_db.org_port<17 & my_port>16)	adj_len += 6;
    if(pack_db.org_port>16 & my_port<17)	adj_len -= 6;

    if(debug)	printf("DEBUG: build_frame: adj_len: %0d\n",adj_len);


    if( pack_db.frame.frame_type[2] )	tagged = 1;

    if(debug)   printf("DEBUG: build_frame: (3)ptr: DAT_LEN_EXACT: %0d\n",
                       check_option(pack_db.frame.data_type, DAT_LEN_EXACT) );


    if(pack_db.data_length<0) {

      case(pack_db.data_length) {
        -1:  pack_db.data_length = 64;
        -2:  pack_db.data_length = 128;
        -3:  pack_db.data_length = 256;
        -4:  pack_db.data_length = 512;
        -5:  pack_db.data_length = 1024;
        -6:  pack_db.data_length = (tagged) ? 1522 : 1518;
        -7:  {
          //               pack_db.data_length = random(pack_db.frame.data_seed); // Vera supports only one random
          
          pack_db.data_length = random();
          min = 64;
          max = (tagged) ? 1522 : 1518;
          while(pack_db.data_length<min | pack_db.data_length>max)
            pack_db.data_length = random();
        }
        -8:  pack_db.data_length = 63;
        -9:  pack_db.data_length = 65;
        -10: pack_db.data_length = (tagged) ? 1521 : 1517;
        -11: pack_db.data_length = (tagged) ? 1523 : 1519;
      }

      pack_db.frame.data_type = pack_db.frame.data_type | DAT_LEN_EXACT;
    }


    if( check_option(pack_db.frame.data_type, DAT_LEN_EXACT) ) {

      // Convert exact length to actual data length, clear exact flag and use that data length from now on.
      //    data_len = pack_db.data_length + header_len - pack_db.header_len[0] + adj_len;

      data_len = pack_db.data_length - header_len - 4;	// data_len - header_len - crc_len


      if(INTER_FEDX)	data_len = data_len - 6;

      pack_db.data_length = data_len;
      pack_db.frame.data_type = pack_db.frame.data_type & DAT_TYPE_MASK;
    }
    else
      data_len = pack_db.data_length;


    if(debug)	printf("DEBUG: build_frame: (3)ptr: %0d\n",ptr);
    if(debug)	printf("DEBUG: build_frame: data_len: %0d\n",data_len);

      if(LLC_HACK & ( (pack_db.frame.frame_type== 5'h3 )| (pack_db.frame.frame_type== 5'h7) )) {
         printf(" build_frame LLC_HACK!!! data_len - %d  \n",pack_db.data_length);
          if(pack_db.flow.frame.frame_type== 5'h3) {
            llc_length = ( pack_db.data_length + header_len + 4)  - 4/*CRC*/ - 12/*L2HEADERS*/ -2/*Type/Length*/ ;
            buf.val[12] = llc_length[15:8];
            buf.val[13] = llc_length[7:0];
	  }
          else {
            llc_length = ( pack_db.data_length + header_len + 4) - 4/*CRC*/ - 12/*L2HEADERS*/ -4/*VLAN ID*/  -2/*Type/Length*/ ;
            buf.val[16] = llc_length[15:8];
            buf.val[17] = llc_length[7:0];
	  }
        }

    if( pack_db.frame.frame_type[2] )	tagged = 1;
    data_gen(	pack_db.frame.data_type,
             pack_db.frame.data_seed,
             data_len,
             buf, ptr, pack_db.options, this, tagged, INTER_FEDX);

    if(debug)	printf("DEBUG: build_frame: (4)ptr: %0d\n",ptr);



    if(INTER_FEDX)
      tmp32 = crc_gen(buf, 2, ptr);   // Skip Interfedx Control Word
    else
      tmp32 = crc_gen(buf, 0, ptr);


    if( check_option( pack_db.options, O_CRC_ERR) ) 
      tmp32 = tmp32 ^ cfg_reg[CFG_CRC_MASK];


    if(!new_crc)
      '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = pack_db.pack_crc;
    else {
      if ( (org_port==17) | (org_port==18) ) {
        if(INTER_FEDX)  { 
          '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = pack_db.pack_crc;
        }
        else {

          tx_status = pack_db.mac.tx_status;

          if(tx_status[14])
            '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = pack_db.pack_crc;
          else '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = tmp32;
        }
      }   //end of if ( (org_port==17) | (org_port==18) )
      else {
        if(INTER_FEDX)  
          '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = pack_db.pack_crc;
        else '{ buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } = tmp32;
      }
    }


    if(debug)	printf("DEBUG: build_frame: (5)ptr: %0d\n",ptr);
    if(debug)	printf("DEBUG: build_frame: Done.\n");
    len = ptr;

    // display_buf( buf,len);
}


task pg::data_gen(integer type, integer seed, integer len, byte_array buf, var integer offset, bit[63:0] options,
                  pg my_root, integer tagged, integer ifedx) {
  integer min,max,n,o,b,l;
  bit [15:0] tmp16;
  bit [7:0] tmp8,s;
  integer exact_len;
  CpgRandom pg_random;
  integer	debug_dg = 0;

  if(debug_dg)	printf("DEBUG: pg::data_gen: input: type: %0d (%h), len: %0d, offset: %0d, tagged: %0d, ifedx: %0d\n",
                       type,type,len,offset,tagged,ifedx);


  exact_len = (type & DAT_LEN_EXACT) ? 1 : 0;
  exact_len = ptr_to_first_pg.check_option(type, DAT_LEN_EXACT);
  type = type & DAT_TYPE_MASK;

  if(len<0)	exact_len = 1;

  case(len) {
    -1:	len = 64;
    -2:	len = 128;
    -3:	len = 256;
    -4:	len = 512;
    -5:	len = 1024;
    -6:	len = (tagged) ? 1522 : 1518;
    -7:	{
      //			len = random(seed);
      len = random();
      min = 64;
      max = (tagged) ? 1522 : 1518;
      while(len<min | len>max)	len = random();
    }
    -8:	len = 63-offset-4;
    -9:	len = 65-offset-4;
    -10:	len = (tagged) ? 1521 : 1517;
    -11:	len = (tagged) ? 1523 : 1519;
  }

  if(exact_len)	{
    len = len-offset-4;
    if(ifedx)	len = len - 4;
  } else		len = len - 2;		 

  if(len<0) {
    len = 0;
    if(!quiet_on) printf("PG[%0d]: WARNING: Data length (payload) is zero.\n",my_port);
     be_msg.print(e_mesg_error, "pg::date_gen", "", "PG[%0d]:  Data length (payload) is zero TESTBENCH ERROR \n", my_port);
    
  }

  o=offset;	 
  b = seed;

  if( my_root != null & check_option(options, O_FRM_LEN_ERR2) )
    len = cfg_reg[CFG_FRM_LEN] - offset -4;

  if(debug_dg)	printf("DEBUG: pg::data_gen: offset: %0d, len: %0d type: %0d\n",o,len,type);

  l = 1;
  case(type) {
    DAT_RAND:{
      sync(ALL,pg_random_event);
      trigger(OFF,pg_random_event);
      pg_random = new(seed);
      for(n=0;n<len;n++){
          buf.val[offset++]= pg_random.nextdata();
        }
      trigger(ON,pg_random_event);
      }

    DAT_SEQ:	 
      for(n=0;n<len;n++)	{
        
        buf.val[offset++]=seed++;
      }

    DAT_W1: 	 
      for(n=0;n<len;n++) {
        tmp8 = 0;
        tmp16=n;
        if(l==1) {
          l=0;	
          if(b<8)	tmp8[7-b++] = 1;
          s = tmp8;
        } else {
          l=1;	
          if( s==0 )
            if(b>7)	tmp8[15-b++] = 1;
        }
        if(b>15)        b = 0;
        buf.val[offset++] = tmp8;
      }
    DAT_W0: 	 
      for(n=0;n<len;n++) {
        tmp8 = 8'hff;
        if(l==1) {
          l=0;	
          if(b<8)	tmp8[7-b++] = 0;
          s = tmp8;
        } else {
          l=1;	
          if( s==8'hff )
            if(b>7)	tmp8[15-b++] = 0;
        }
        if(b>15)        b = 0;
        buf.val[offset++] = tmp8;
      }
    DAT_FC_PAUSE:	 
    {
      len = 64-offset-4;
      o = offset;
      for(n=0;n<len;n++)	buf.val[offset++] = 0;
      '{buf.val[o++], buf.val[o++]} = FC_PAUSE_OPCODE;
      '{buf.val[o++], buf.val[o++]} = seed;	 
    }
    DAT_FC_PAUSE_ERR:	 
    {
      bit [15:0] tmp16 = cfg_reg[CFG_CRC_MASK];
      len = 64-offset-4;
      o = offset;
      for(n=0;n<len;n++)	buf.val[offset++] = 0;
      '{buf.val[o++], buf.val[o++]} = FC_PAUSE_OPCODE ^ tmp16;
      '{buf.val[o++], buf.val[o++]} = seed;	 
    }
    DAT_ALL0: 	 
    {
      for(n=0;n<len;n++)	{
        
        buf.val[offset++]=8'hff;
      }
    }
    DAT_ALL1: 	 
    {
      for(n=0;n<len;n++)	{
        
        buf.val[offset++]=8'h00;
      }
    }
    default:
    {
      print_err();
      printf("pg::data_gen: invalid type (%0d)\n",type);
    }
  }

  if(debug_dg & 0)
    for(n=0;n<len;n++)
      printf("pg::data_gen: buf[%0d]: %h\n",o+n,buf.val[o+n]);
}



function bit [31:0] pg::crc32_add(bit [7:0] data, bit [31:0] crc) {
  bit feedback;
  integer i;                    

  for(i=0;i<8;i=i+1) begin
    
    
    feedback    = crc[31] ^ data[i]; 
    crc[31:27] = crc[30:26]; 
    crc[26] = crc[25] ^ feedback;
    crc[25] = crc[24];
    crc[24] = crc[23];
    crc[23] = crc[22] ^ feedback;
    crc[22] = crc[21] ^ feedback;
    crc[21:17] = crc[20:16];
    crc[16] = crc[15] ^ feedback;
    crc[15:13] = crc[14:12];
    crc[12] = crc[11] ^ feedback;
    crc[11] = crc[10] ^ feedback;
    crc[10] = crc[9] ^ feedback;
    crc[9] = crc[8];
    crc[8] = crc[7] ^ feedback;
    crc[7] = crc[6] ^ feedback;
    crc[6] = crc[5];
    crc[5] = crc[4] ^ feedback;
    crc[4] = crc[3] ^ feedback;
    crc[3] = crc[2];
    crc[2] = crc[1] ^ feedback;
    crc[1] = crc[0] ^ feedback;
    crc[0] = feedback;
  end

  crc32_add = crc;

}

function integer pg::check_option(bit [63:0] option, bit [63:0] flag) {
  if((option[63:0] & flag[63:0]) > 64'h0)	check_option = 1;
  else					check_option = 0;
}


function bit [7:0] pg::class_mask(integer funct, bit[7:0] a, bit[7:0] b) {
  case(funct) {
    CLF_SRC: class_mask = a;
    CLF_DST: class_mask = b;
    CLF_OR:  class_mask = a && b;
    CLF_AND: class_mask = a || b;
    default: class_mask = 8'h00;
  }
}





task pg::send_packet(bit [3:0] ptype, byte_array buf, integer len, bit [63:0] options) {
  integer n;

  case(my_port) {
    0:	{
      if (port_speed == 4)
        send_packet_xgmii (xgm0,ptype, buf, len, options);
      else if (port_speed == 3)
        send_packet_gmii (gm0, ptype, buf, len, options);
      else 
        send_packet_mii (m0,ptype, buf, len, options);
    }

    1:	{ 
      if (port_speed == 4)
        send_packet_xgmii (xgm1,ptype, buf, len, options);
      else if (port_speed == 3)
        send_packet_gmii (gm1, ptype, buf, len, options);
      else 
        send_packet_mii (m1, ptype, buf, len, options);
    }
    2:	{
      if (port_speed == 3)
        send_packet_gmii (gm2, ptype, buf, len, options);
      else 
        send_packet_mii (m2, ptype, buf, len, options);
    }
    3:	{ 
      if (port_speed == 3)
        send_packet_gmii (gm3, ptype, buf, len, options);
      else 
        send_packet_mii (m3, ptype, buf, len, options);
    }

  }
}


task pg::assert_col_tx (mii_def port_bind, bit [63:0] options) {
  integer itmp;
  
  
  while(rxdv_set == 0)	@(posedge port_bind.$rxclk);

  
  
  if( check_option( options, O_RX_COL) & cfg_reg[CFG_COL_LEN]>0 & !tx_done ) {
    itmp = cfg_reg[CFG_COL_DEL];
    while(itmp>0 & !tx_done) {
      itmp--;
      @(posedge port_bind.$rxclk);
    }
    port_bind.$rxcol = 1 async;
    itmp = cfg_reg[CFG_COL_LEN];
    while(itmp>0 & !tx_done) {
      itmp--;
      @(posedge port_bind.$rxclk);
    }
    port_bind.$rxcol = 0 async;
  }
  
}


task pg::assert_mii_err (mii_def port_bind ) {
  integer cnt=0;

  if(tx_err_start==-1)	return;

  if(tx_err_len<1) {
    printf("PG: WARNING: tx_err injection length to short. (Start: %0d, Length: %0d)\n",
           tx_err_start,tx_err_len);
    return;
  }

  while(cnt++ < tx_err_start & !tx_done) 
    @(posedge port_bind.$rxclk);

  if(!tx_done) {
    port_bind.$rxerr = 1;
    cnt=0;
    while(cnt++ < tx_err_len & !tx_done)
      @(posedge port_bind.$rxclk);
    port_bind.$rxerr = 0;
  } else
  printf("PG: WARNING: Packet was sent before tx_err could be assrted.(Start: %0d, Length: %0d)\n",
         tx_err_start,tx_err_len);

  tx_err_start = -1;
}

task pg::send_packet_mii (mii_def port_bind, bit [3:0] ptype, byte_array buf, integer len, bit [63:0] options) {
  integer n, cnt;
  bit [7:0] tmp;
  bit [63:0] current_time;
  bit [63:0] min_gap, time_tmp;

  tx_done = 0;

  if(debug_mii==1)
    printf("DEBUG: PG low tx started: current_time: %0d\n",  {get_time(HI),get_time(LO)} );
  

  current_time = {get_time(HI),get_time(LO)};
  if(port_speed==1)	min_gap = 800 * MII_IP_GAP;	 
  else			min_gap = 80 * MII_IP_GAP;	 
  time_tmp = current_time - last_tx_time;
  if(debug_mii_tx)
    printf("DEBUG: PG low tx: last_time: %0d, current_time: %0d, diff: %0d\n",
           last_tx_time,current_time,time_tmp);
  if((time_tmp < min_gap) & !check_option(options, O_NO_IP_GAP_FIX) & !check_option(options, O_CUSTOM_IP_GAP) ) {
    time_tmp = min_gap - time_tmp;
    if(debug_mii_tx) printf("DEBUG: PG low tx: Min_gap: %0d, gap_diff: %0d\n",min_gap,time_tmp);
    if(port_speed==1)	time_tmp = time_tmp / 400;
    else			time_tmp = time_tmp / 40;
    if(debug_mii_tx) printf("DEBUG: PG low tx: waiting additional %0d cycles\n",time_tmp);
    repeat(time_tmp)	@(posedge port_bind.$rxclk);
  } else
  if( check_option(options, O_CUSTOM_IP_GAP) ) {
    repeat(cfg_reg[CFG_IP_GAP])	@(posedge port_bind.$rxclk);
  }

  fork {
    // assert_mii_err  (get_bind( port_bind ));
    assert_mii_err  ( port_bind );
  }
  join none


  port_bind.$rxdv = 1;
  rxdv_set = 1;
  

  if( check_option(options, O_PREAMB_ERR) )	cnt = cfg_reg[CFG_PRAMB_CNT];
  else						cnt = 7;

  
  for(n=0;n<cnt;n++) {
    tmp = MII_PREAMBLE;
    port_bind.$rxd = tmp[3:0];
    @(posedge port_bind.$rxclk);
    port_bind.$rxd = tmp[7:4];
    @(posedge port_bind.$rxclk);
  }

  if( check_option(options, O_SFD_ERR) )	tmp = cfg_reg[CFG_SFD_TOKEN];
  else					tmp = MII_SOF;

  port_bind.$rxd = tmp[3:0];
  @(posedge port_bind.$rxclk);
  port_bind.$rxd = tmp[7:4];
  @(posedge port_bind.$rxclk);

  for(n=0;n<len;n++) {
    if(debug_mii==1)	printf("MII: Sending Byte[%0d]: %h\n", n, buf.val[n] );
    tmp = buf.val[n];
    port_bind.$rxd = tmp[3:0];
    @(posedge port_bind.$rxclk);
    
    if(n != (len-1) | !check_option(options, O_NIBBLE_ERR) ) {	 
      port_bind.$rxd = tmp[7:4];
      @(posedge port_bind.$rxclk);
    }
  }

  port_bind.$rxdv = 0;
  rxdv_set = 0;

  tmp = MII_PREAMBLE;
  port_bind.$rxd = tmp[3:0];

  @(posedge port_bind.$rxclk); 
  tx_done = 1;
  last_tx_time =  {get_time(HI),get_time(LO)};

}


task pg::assert_gmii_err (gmii_def port_bind) {
  integer cnt=0;

  if(tx_err_start==-1)	return;

  if(tx_err_len<1) {
    printf("PG: WARNING: tx_err injection length to short. (Start: %0d, Length: %0d)\n",
           tx_err_start,tx_err_len);
    return;
  }

  while(cnt++ < tx_err_start & !tx_done) 
    @(posedge port_bind.$rxclk);

  if(!tx_done) {
    port_bind.$rxerr = 1;
    cnt=0;
    while(cnt++ < tx_err_len & !tx_done)
      @(posedge port_bind.$rxclk);
    port_bind.$rxerr = 0;
  } else
  printf("PG: WARNING: Packet was sent before tx_err could be assrted.(Start: %0d, Length: %0d)\n",
         tx_err_start,tx_err_len);

  tx_err_start = -1;
}

task pg::send_packet_gmii (gmii_def port_bind, bit [3:0] ptype, byte_array buf, integer len, bit [63:0] options) {
  integer n, cnt;
  bit [7:0] tmp;
  bit [63:0] current_time;
  bit [63:0] min_gap, time_tmp;
  integer ipg_clock_diffs;
  integer align_cycles;  //hummer
  bit [63:0] ipg_diffs;
  integer need_extra_clocks;
  integer sfd;
  
  tx_done = 0;

  //current_time = {get_time(HI),get_time(LO)};
  current_time = clock_counter;
  min_gap = GMII_IP_GAP - 1;			 

  // PORT2 gets the IPG given by the plusarg PKTGEN_PORT2_1G_IPG
  if (get_plus_arg (CHECK, "PKTGEN_PORT2_1G_IPG") && (my_port==2))
   min_gap = get_plus_arg (NUM, "PKTGEN_PORT2_1G_IPG");

  // PORT3 gets the IPG given by the plusarg PKTGEN_PORT3_1G_IPG
  if (get_plus_arg (CHECK, "PKTGEN_PORT3_1G_IPG") && (my_port==3))
   min_gap = get_plus_arg (NUM, "PKTGEN_PORT3_1G_IPG");

  time_tmp = current_time - last_tx_time;

  ipg_diffs = time_tmp; // 800 ps
  ipg_clock_diffs = 0; //hummer
  if(ipg_diffs < min_gap)  { 
    need_extra_clocks = 1;
    ipg_clock_diffs = min_gap - ipg_diffs;
  }
  else need_extra_clocks = 0;
  
  //hummer
  //////////////////align logic>>>>>>>>>>>>>>>>
  //first calculate where the align point is?
  align_cycles = 4-(((current_time-prev_current_time))%4);
  //see if the align point is beyond IPG
  //if so, lets move the IPG to align point
  if(align_cycles >= ipg_clock_diffs) {
    ipg_clock_diffs = align_cycles;
    need_extra_clocks = 1;
  }
  else
    //if align is before IPG, we need to go to next align point
    //this next align point is 4-(difference of the current align-ipg)
    if(align_cycles < ipg_clock_diffs) {
      //also make sure the IPG is not a multiple of next align
      if((ipg_clock_diffs-align_cycles)%4)
        ipg_clock_diffs += 4-(ipg_clock_diffs-align_cycles)%4;
    }
  //////////////////align logic<<<<<<<<<<<<<<<<

  if(debug_mii_tx)
    printf("DEBUG: PG low tx: last_time: %0d, current_time: %0d, diff: %0d\n",
           last_tx_time,current_time,time_tmp);


  if( !check_option(options, O_NO_IP_GAP_FIX) & !check_option(options, O_CUSTOM_IP_GAP)  & need_extra_clocks ) {
    repeat(ipg_clock_diffs) @(posedge port_bind.$rxclk);
  } else 
  if( check_option(options, O_CUSTOM_IP_GAP) ) {
    repeat(cfg_reg[CFG_IP_GAP])	@(posedge port_bind.$rxclk);
  }

  fork
    // assert_gmii_err (get_bind( port_bind));
    assert_gmii_err ( port_bind);
  join none

  prev_current_time =  clock_counter;

  //port_bind.$rxd =  XGMII_SOP;
  port_bind.$rxdv = 1;
  /*  @(posedge port_bind.$rxclk);  */

  if( check_option(options, O_PREAMB_ERR) )	cnt = cfg_reg[CFG_PRAMB_CNT];
  else						cnt = 7;


  for(n=0;n<cnt;n++) {
    port_bind.$rxd = GMII_PREAMBLE;
    @(posedge port_bind.$rxclk);
  }


  port_bind.$rxdv = 1;

 // printf("DEBUG pack_db.options - %x preamble_cnt - %d sfd - %d \n",options,cfg_reg[CFG_PRAMB_CNT],cfg_reg[CFG_SFD_TOKEN]);
  if( check_option(options, O_SFD_ERR) ) {
      sfd = cfg_reg[CFG_SFD_TOKEN];
      if(sfd!=-1) {
        port_bind.$rxd = cfg_reg[CFG_SFD_TOKEN];
       @(posedge port_bind.$rxclk);
      } else {
       printf("SKIP SFD GENERATION!!\n");
     }
  }
  else{
    port_bind.$rxd = GMII_SOF;
   @(posedge port_bind.$rxclk);
  }

  for(n=0;n<len;n++) {
    if(debug_gmii==1)	printf("GMII: Sending Byte[%0d]: %h\n", n, buf.val[n] );
    if(n != (len-1) | !check_option(options, O_NIBBLE_ERR) ) {	 
      port_bind.$rxd = buf.val[n];
      @(posedge port_bind.$rxclk);
    }
  }

  last_tx_time =  clock_counter;
  port_bind.$rxdv = 0;
  port_bind.$rxd = GMII_PREAMBLE;

  tx_done = 1;
  port_bind.$rxerr = 0;
  @(posedge port_bind.$rxclk); 
  //last_tx_time =  {get_time(HI),get_time(LO)};

}


task pg::assert_xgmii_err (xgmii_def port_bind) {
  integer cnt=0;

  if(tx_err_start==-1)	return;

  if(tx_err_len<1) {
    printf("PG: WARNING: tx_err injection length to short. (Start: %0d, Length: %0d)\n",
           tx_err_start,tx_err_len);
    return;
  }

  while(cnt++ < tx_err_start & !tx_done) 
    @(posedge port_bind.$rxclk_int);

  if(!tx_done) {
    port_bind.$rxerr = 1;
    cnt=0;
    while(cnt++ < tx_err_len & !tx_done)
      @(posedge port_bind.$rxclk_int);
    port_bind.$rxerr = 0;
  } else
  printf("PG: WARNING: Packet was sent before tx_err could be assrted.(Start: %0d, Length: %0d)\n",
         tx_err_start,tx_err_len);

  tx_err_start = -1;
}


task pg::send_packet_xgmii (xgmii_def port_bind,bit [3:0] ptype, byte_array buf, integer len, bit [63:0] options) {
  integer n, cnt;
  bit [7:0] tmp;
  bit [63:0] current_time;
  bit [63:0] min_gap, time_tmp;
  integer ipg_clock_diffs;
  integer align_cycles;  //hummer
  bit [63:0] ipg_diffs;
  integer need_extra_clocks;
  integer sfd;

  tx_done = 0;
 printf("send_packet_xgmii - Enteri Time - %d \n",{get_time(HI),get_time(LO)});
  // current_time = {get_time(HI),get_time(LO)};
  current_time = clock_counter;
  min_gap = 8 * XGMII_IP_GAP   ;			 // TOADS----

  min_gap = 4;

  // both ports at the same IPG, if the plusarg PKTGEN_10G_IPG is specified
  // this plusarg is really a redundant after we had PKTGEN_PORT0_10G_IPG/PKTGEN_PORT1_10G_IPG
  // but want to keep this for some old test runs which use this
  if (get_plus_arg (CHECK, "PKTGEN_10G_IPG"))
    min_gap = get_plus_arg (NUM, "PKTGEN_10G_IPG");
  
  // PORT0 gets the IPG given by the plusarg PKTGEN_PORT0_10G_IPG
  if (get_plus_arg (CHECK, "PKTGEN_PORT0_10G_IPG") && (my_port==0))
   min_gap = get_plus_arg (NUM, "PKTGEN_PORT0_10G_IPG");

  // PORT1 gets the IPG given by the plusarg PKTGEN_PORT1_10G_IPG
  if (get_plus_arg (CHECK, "PKTGEN_PORT1_10G_IPG") && (my_port==1))
   min_gap = get_plus_arg (NUM, "PKTGEN_PORT1_10G_IPG");


  time_tmp = current_time - last_tx_time;

  ipg_diffs = time_tmp; // 800 ps
  ipg_clock_diffs = 0; //hummer
  if(ipg_diffs < min_gap)  { 
    need_extra_clocks = 1;
    ipg_clock_diffs = min_gap - ipg_diffs;
  }
  else need_extra_clocks = 0;

  //hummer
  //////////////////align logic>>>>>>>>>>>>>>>>
  //first calculate where the align point is?
  align_cycles = 4-(((current_time-prev_current_time))%4);
  //see if the align point is beyond IPG
  //if so, lets move the IPG to align point
  if(align_cycles >= ipg_clock_diffs) {
    ipg_clock_diffs = align_cycles;
    need_extra_clocks = 1;
  }
  else
    //if align is before IPG, we need to go to next align point
    //this next align point is 4-(difference of the current align-ipg)
    if(align_cycles < ipg_clock_diffs) {
      //also make sure the IPG is not a multiple of next align
      if((ipg_clock_diffs-align_cycles)%4)
        ipg_clock_diffs += 4-(ipg_clock_diffs-align_cycles)%4;
    }
  //////////////////align logic<<<<<<<<<<<<<<<<

  
  printf("pg::send_packet_xgmii: DEBUG--len - %d \n",len);
  printf("pg::send_packet_xgmii: DEBUG--IPG ipg_diff - %d ipg_clock_diffs - %d need_extra_clocks - %d \n",ipg_diffs,ipg_clock_diffs,need_extra_clocks);

  if(debug_xgmii_tx)
    printf("DEBUG: PG low tx: last_time: %0d, current_time: %0d, diff: %0d options = %x \n",
           last_tx_time,current_time,time_tmp,options);
  if( !check_option(options, O_NO_IP_GAP_FIX) & !check_option(options, O_CUSTOM_IP_GAP)  & need_extra_clocks ) {
    repeat(ipg_clock_diffs) @(posedge port_bind.$rxclk_int);

  } else if( check_option(options, O_CUSTOM_IP_GAP) ) {
    
    repeat(cfg_reg[CFG_IP_GAP])	@(posedge port_bind.$rxclk_int);
  }

  fork
    // assert_xgmii_err (get_bind(  port_bind  ) );
    assert_xgmii_err (port_bind  );
  join none

  port_bind.$rxdv = 1;
  

  // prev_current_time =  {get_time(HI),get_time(LO)};  //hummer
  prev_current_time =  clock_counter;


  port_bind.$rxd =  XGMII_SOP;
  port_bind.$rxdv = 1;
  @(posedge port_bind.$rxclk_int);

  if( check_option(options, O_PREAMB_ERR) )	cnt = cfg_reg[CFG_PRAMB_CNT];
  else						cnt = 6;

  for(n=0;n<cnt;n++) {
    port_bind.$rxd =  XGMII_PREAMBLE;
    port_bind.$rxdv = 0;
    
    @(posedge port_bind.$rxclk_int);
  }


  port_bind.$rxdv = 0;
  // printf("DEBUG pack_db.options - %x preamble_cnt - %d sfd - %d \n",options,cfg_reg[CFG_PRAMB_CNT],cfg_reg[CFG_SFD_TOKEN]);
  if( check_option(options, O_SFD_ERR) ) {
      sfd = cfg_reg[CFG_SFD_TOKEN];
      if(sfd!=-1) {
  	port_bind.$rxd = cfg_reg[CFG_SFD_TOKEN];
       @(posedge port_bind.$rxclk_int);
      } else {
       printf("SKIP SFD GENERATION!!\n");
     }
  }
  else{
    port_bind.$rxd = XGMII_SOF;
   @(posedge port_bind.$rxclk_int);
  }
  

  for(n=0;n<len;n++) {
    // printf("XGMII: Sending Byte[%0d]: %h\n", n, buf.val[n] );
    if(n != (len-1) | !check_option(options, O_NIBBLE_ERR) ) {	 
      port_bind.$rxd = buf.val[n];
      @(posedge port_bind.$rxclk_int);
    }
  }

  port_bind.$rxdv = 1;
  
  port_bind.$rxd = XGMII_EOP;
  @(posedge port_bind.$rxclk_int);

  // last_tx_time =  {get_time(HI),get_time(LO)};
  last_tx_time =  clock_counter;
  port_bind.$rxd = XGMII_IDLE;
  port_bind.$rxdv = 1;

  tx_done = 1;
  port_bind.$rxerr = 0;
  @(posedge port_bind.$rxclk_int); 
  //prev_current_time = current_time; //hummer
 printf("send_packet_xgmii - Exit Time - %d \n",{get_time(HI),get_time(LO)});
}


task pg::wait_clk(integer count) {
  repeat(count)   @(posedge CLOCK);
}

task pg::wait_tx_clk(integer count) {
  case(my_port) {
    0:	wait_tx_clk_if (m0 , count);
    1:	wait_tx_clk_if (m1 , count);
    2:	wait_tx_clk_if (m2 , count);
    3:	wait_tx_clk_if (m3 , count);
  }
}
task pg::wait_tx_clk_if ( mii_def port_bind, integer count) {
  repeat(count)   @(posedge port_bind.$txclk);
}

task pg::wait_rx_clk(integer count) {
  case(my_port) {
    0:	wait_tx_clk_if (m0 , count);
    1:	wait_tx_clk_if (m1 , count);
    2:	wait_tx_clk_if (m2 , count);
    3:	wait_tx_clk_if (m3 , count);
  }
}

task pg::wait_rx_clk_if ( mii_def port_bind, integer count) {
  repeat(count)   @(posedge port_bind.$rxclk);
}


task pg::new(integer my_porti, (bit [3:0] ptype=0)) {
  integer n,i;

  my_port = my_porti;		 
  port_type = ptype;

  ifedx_control = 16'h0001;	 
  // trigger(ON,pkt_gen_lock);
  pkt_gen_lock = alloc(SEMAPHORE,0,1,0);

  semaphore_put(pkt_gen_lock,1);
  trigger(ON,pg_random_event);

  
  if(my_port>15) {
    printf("PG: INIT: Warning: Port %0d is invalid or out of range.\n", my_port);
  }

  if(!quiet_on)
    printf("INFO: Packet Generator attaching to port %0d\n",my_port);

  
  if(pg_used_ports[my_port] == 1) {
    printf("PG: INIT: Port %0d already in use.\n", my_port);
    
    terminate;
  }
  pg_used_ports[my_port] = 1;

  
  for(n=0;n<60;n++) {
    l3_class[n] = new;
  }
  for(n=0;n<40;n++) {
    l3_mask[n] = new;
  }

  
  queue_lock = alloc(SEMAPHORE,0,1,1);
  if(queue_lock == 0) {
    printf("PG: INIT: Could not allocate spaphore queue_lock.\n");
  }

  
  mb_q = alloc(MAILBOX, 0, 1);
  pkt_gen_sync =  alloc(MAILBOX, 0, 1);
  if(mb_q == 0) {
    printf("PG: INIT: Could not allocate mailbox mb_q.\n");
  }
  mbox_id.pg_mb[my_port] = alloc(MAILBOX, 0, 1);
  if(mbox_id.pg_mb[my_port] == 0) {
    printf("PG: INIT: Could not allocate mailbox mbox_id.pg_mb[%0d].\n",my_port);
  }

  
  fork
    pkt_auto_tx();
  join none

  
  if(ptr_to_first_pg==null)	ptr_to_first_pg = this;

  
  last_tx_time = {get_time(HI),get_time(LO)};

  for(n=0;n<CFG_LAST_ENTRY;n++)	cfg_reg[n] = 0;

  
  
  for(n=0;n<40; n++)
    for(i=0;i<12;i++) {                    
      l3_mask[n].val[i] = 8'hff;
    }
  for(n=0;n<60;n++)
    for(i=0;i<12;i++) {                   
      l3_class[n].val[i] = 0;
    }
  for(n=CL_RSVP;n<CL_USER1;n++) {
    l3_class[n].val[0] = 8'h08;
    l3_class[n].val[2] = 8'h45;
  }



  
  l3_class[CL_ARP].val[0]   = 8'h08;
  l3_class[CL_ARP].val[1]   = 8'h06;
  l3_class[CL_RARP].val[0]  = 8'h80;
  l3_class[CL_RARP].val[1]  = 8'h35;
  l3_class[CL_RSVP].val[0]  = 8'h08;
  l3_class[CL_RSVP].val[11] = 8'h2e;
  l3_class[CL_IGMP].val[0]  = 8'h08;
  l3_class[CL_IGMP].val[11] = 8'h02;
  l3_class[CL_ICMP].val[0]  = 8'h08;
  l3_class[CL_ICMP].val[11] = 8'h01;
  l3_class[CL_GRE].val[0]   = 8'h08;
  l3_class[CL_GRE].val[11]  = 8'h2F;
  l3_class[CL_PIM].val[0]   = 8'h08;
  l3_class[CL_PIM].val[11]  = 8'h67;


  
  l3_class[CL_IP_TUN_V4_V4].val[0]  = 8'h08;
  l3_class[CL_IP_TUN_V4_V4].val[2]  = 8'h45;
  l3_class[CL_IP_TUN_V4_V4].val[11] = 8'h04;  

  
  l3_class[CL_IP_TUN_V4_V6].val[0]  = 8'h08;
  l3_class[CL_IP_TUN_V4_V6].val[2]  = 8'h45;
  l3_class[CL_IP_TUN_V4_V6].val[11] = 8'h29;  

  l3_class[CL_IP].val[0]        = 8'h08;
  l3_class[CL_IP].val[2]        = 8'h45;

  
  l3_class[CL_IP_FRAG].val[0] = 8'h08;
  l3_class[CL_IP_FRAG].val[2] = 8'h45;
  l3_class[CL_IP_FRAG].val[8] = 8'h20;
  
  l3_class[CL_IP_FRAG].val[11] = 8'h12;
  
  l3_mask[CL_IP_FRAG].val[8]  = 8'h00;
  l3_mask[CL_IP_FRAG].val[9]  = 8'h00;

  l3_class[CL_IP_SEC_AH].val[0] = 8'h08;
  l3_class[CL_IP_SEC_AH].val[2] = 8'h48; 
  l3_class[CL_IP_SEC_AH].val[11]= 8'h33;
  l3_class[CL_IP_SEC_ESP].val[0]= 8'h08;
  l3_class[CL_IP_SEC_ESP].val[2]= 8'h48; 
  l3_class[CL_IP_SEC_ESP].val[11]= 8'h32;
  l3_class[CL_IP_OPT].val[0]    = 8'h08;
  l3_class[CL_IP_OPT].val[2]    = 8'h48;

  
  l3_class[CL_UDP].val[0]       = 8'h08;
  l3_class[CL_UDP].val[2]       = 8'h45;
  l3_class[CL_UDP].val[11]      = 8'h11;
  l3_class[CL_UDP_OPT].val[2]   = 8'h48;
  l3_class[CL_UDP_OPT].val[11]  = 8'h11;
  l3_class[CL_UDP_FRAG].val[0]  = 8'h08;
  l3_class[CL_UDP_FRAG].val[2]  = 8'h45;
  l3_class[CL_UDP_FRAG].val[8] = 8'h01;
  l3_class[CL_UDP_FRAG].val[9] = 8'h00;
  l3_class[CL_UDP_FRAG].val[11] = 8'h11;
  l3_mask[CL_UDP_FRAG].val[8] = 8'h00;
  l3_mask[CL_UDP_FRAG].val[9] = 8'h00;
  
  
  l3_class[CL_TCP].val[0]       = 8'h08;
  l3_class[CL_TCP].val[2]       = 8'h45;
  l3_class[CL_TCP].val[11]      = 8'h06;
  l3_class[CL_TCP_OPT].val[0]   = 8'h08;
  l3_class[CL_TCP_OPT].val[2]   = 8'h45;
  l3_class[CL_TCP_OPT].val[11]  = 8'h06;
  l3_class[CL_TCP_FRAG].val[0]  = 8'h08;
  l3_class[CL_TCP_FRAG].val[2]  = 8'h45;
  l3_class[CL_TCP_FRAG].val[8]   = 8'h21;
  l3_class[CL_TCP_FRAG].val[9]   = 8'h00;
  l3_class[CL_TCP_FRAG].val[11]  = 8'h06;
  l3_mask[CL_TCP_FRAG].val[8]    = 8'h00;
  l3_mask[CL_TCP_FRAG].val[9]    = 8'h00;



  
  l3_class[CL_IP_V6].val[0]         = 8'h86;
  l3_class[CL_IP_V6].val[1]         = 8'hdd;
  l3_class[CL_IP_V6].val[2]         = 8'h60;
  l3_class[CL_ICMP_IP_V6].val[0]    = 8'h86;
  l3_class[CL_ICMP_IP_V6].val[1]    = 8'hdd;
  l3_class[CL_ICMP_IP_V6].val[2]    = 8'h60;
  l3_class[CL_ICMP_IP_V6].val[8]    = 8'h01;
  l3_class[CL_IGMP_IP_V6].val[0]    = 8'h86;
  l3_class[CL_IGMP_IP_V6].val[1]    = 8'hdd;
  l3_class[CL_IGMP_IP_V6].val[2]    = 8'h60;
  l3_class[CL_IGMP_IP_V6].val[8]    = 8'h02;
  l3_class[CL_RSVP_IP_V6].val[0]    = 8'h86;
  l3_class[CL_RSVP_IP_V6].val[1]    = 8'hdd;
  l3_class[CL_RSVP_IP_V6].val[2]    = 8'h60;
  l3_class[CL_RSVP_IP_V6].val[8]    = 8'h2E;
  l3_class[CL_GRE_IP_V6].val[0]     = 8'h86;
  l3_class[CL_GRE_IP_V6].val[1]     = 8'hdd;
  l3_class[CL_GRE_IP_V6].val[2]     = 8'h60;
  l3_class[CL_GRE_IP_V6].val[8]     = 8'h2F;
  l3_class[CL_PIM_IP_V6].val[0]     = 8'h86;
  l3_class[CL_PIM_IP_V6].val[1]     = 8'hdd;
  l3_class[CL_PIM_IP_V6].val[2]     = 8'h60;
  l3_class[CL_PIM_IP_V6].val[8]     = 8'h67;
  l3_class[CL_IP_V6_SEC_AH].val[0]  = 8'h86;
  l3_class[CL_IP_V6_SEC_AH].val[1]  = 8'hdd;
  l3_class[CL_IP_V6_SEC_AH].val[2]  = 8'h60;
  l3_class[CL_IP_V6_SEC_AH].val[8]  = 8'h33;
  l3_class[CL_IP_V6_SEC_ESP].val[0] = 8'h86;
  l3_class[CL_IP_V6_SEC_ESP].val[1] = 8'hdd;
  l3_class[CL_IP_V6_SEC_ESP].val[2] = 8'h60;
  l3_class[CL_IP_V6_SEC_ESP].val[8] = 8'h32;

  
  l3_class[CL_IP_TUN_V6_V6].val[0]     = 8'h86;
  l3_class[CL_IP_TUN_V6_V6].val[1]     = 8'hdd;
  l3_class[CL_IP_TUN_V6_V6].val[8]     = 8'h29;  

  
  l3_class[CL_IP_TUN_V6_V4].val[0]     = 8'h86;
  l3_class[CL_IP_TUN_V6_V4].val[1]     = 8'hdd;
  l3_class[CL_IP_TUN_V6_V4].val[8]     = 8'h04;  

  
  l3_class[CL_UDP_IP_V6].val[0]       = 8'h86;
  l3_class[CL_UDP_IP_V6].val[1]       = 8'hDD;
  l3_class[CL_UDP_IP_V6].val[2]       = 8'h60;
  l3_class[CL_UDP_IP_V6].val[8]       = 8'h11;
  l3_class[CL_UDP_OPT_IP_V6].val[0]   = 8'h86;
  l3_class[CL_UDP_OPT_IP_V6].val[2]   = 8'h48;
  l3_class[CL_UDP_OPT_IP_V6].val[8]   = 8'h11;
  l3_class[CL_UDP_FRAG_IP_V6].val[0]  = 8'h86;
  l3_class[CL_UDP_FRAG_IP_V6].val[2]  = 8'h45;
  l3_class[CL_UDP_FRAG_IP_V6].val[8]  = 8'h01;
  l3_class[CL_UDP_FRAG_IP_V6].val[5] = 8'h12;
  l3_class[CL_UDP_FRAG_IP_V6].val[6] = 8'h12;
  l3_class[CL_UDP_FRAG_IP_V6].val[8] = 8'h11;
  l3_mask[CL_UDP_FRAG_IP_V6].val[8] = 8'h00;
  l3_mask[CL_UDP_FRAG_IP_V6].val[9] = 8'h00;


  
  l3_class[CL_TCP_IP_V6].val[0]       = 8'h86;
  l3_class[CL_TCP_IP_V6].val[1]       = 8'hDD;
  l3_class[CL_TCP_IP_V6].val[2]       = 8'h60;
  l3_class[CL_TCP_IP_V6].val[8]       = 8'h06;
  l3_class[CL_TCP_OPT_IP_V6].val[0]   = 8'h86;
  l3_class[CL_TCP_OPT_IP_V6].val[1]   = 8'hDD;
  l3_class[CL_TCP_OPT_IP_V6].val[2]   = 8'h60;
  l3_class[CL_TCP_OPT_IP_V6].val[8]   = 8'h06;

  l3_class[CL_TCP_FRAG_IP_V6].val[0]  = 8'h86;
  l3_class[CL_TCP_FRAG_IP_V6].val[2]  = 8'h45;
  l3_class[CL_TCP_FRAG_IP_V6].val[5]  = 8'h12;
  l3_class[CL_TCP_FRAG_IP_V6].val[8]  = 8'h06;
  l3_mask[CL_TCP_FRAG_IP_V6].val[5]    = 8'h00;
  l3_mask[CL_TCP_FRAG_IP_V6].val[6]    = 8'h00;

  

  

  cfg_reg[CFG_IP_GAP]  = 0;
  cfg_reg[CFG_UDP_LEN] = 0;
  cfg_reg[CFG_UDP_CSM] = 0;
  cfg_reg[CFG_TCP_SEQ] = 0;
  cfg_reg[CFG_TCP_ACK] = 0;
  cfg_reg[CFG_TCP_LEN] = 4'b0101;
  cfg_reg[CFG_TCP_FLAG]= 0;
  cfg_reg[CFG_TCP_WIN] = 0;
  cfg_reg[CFG_TCP_CSM] = 0;
  cfg_reg[CFG_TCP_URG] = 0;

  
  
  
  

  fork
    case(my_port) {
      
      0: if (get_plus_arg(CHECK, "MAC_SPEED0=")) {
        mac_speed = get_plus_arg(NUM,"MAC_SPEED0=");
        config_tx (m0 , mac_speed);
      }

      1: if (get_plus_arg(CHECK, "MAC_SPEED1=")) {
        mac_speed = get_plus_arg(NUM,"MAC_SPEED1=");
        config_tx (m1 , mac_speed);
      }

      2: if (get_plus_arg(CHECK, "MAC_SPEED2=")) {
        mac_speed = get_plus_arg(NUM,"MAC_SPEED2=");
        config_tx (m2 , mac_speed);
      }

      3: if (get_plus_arg(CHECK, "MAC_SPEED3=")) {
        mac_speed = get_plus_arg(NUM,"MAC_SPEED3=");
        config_tx (m3 , mac_speed);
      }

    }

    
    
  join none
  fork {
   count_clock();
  }
  join none
  
}


task pg::count_clock() {

// This is just a HACK to get going
clock_counter = 0;
case(my_port) {
  0: if (port_speed == 4) {
        while(1) {
          @(posedge xgm0.$rxclk_int); clock_counter = clock_counter + 1;
        }
     } else if (port_speed == 3) {
        while(1) {
          @(posedge gm0.$rxclk); clock_counter = clock_counter + 1;
        }
     } else {
        while(1) {
          @(posedge m0.$rxclk); clock_counter = clock_counter + 1;
        }
     }

    1: if (port_speed == 4) {
        while(1) {
          @(posedge xgm1.$rxclk_int); clock_counter = clock_counter + 1;
        }
     } else if (port_speed == 3) {
        while(1) {
          @(posedge gm1.$rxclk); clock_counter = clock_counter + 1;
        }
     } else {
        while(1) {
          @(posedge m1.$rxclk); clock_counter = clock_counter + 1;
        }
     }
  2: if (port_speed == 4) {
     } else if (port_speed == 3) {
        while(1) {
          @(posedge gm2.$rxclk); clock_counter = clock_counter + 1;
        }
     } else {
        while(1) {
          @(posedge m2.$rxclk); clock_counter = clock_counter + 1;
        }
     }
  3: if (port_speed == 4) {
     } else if (port_speed == 3) {
        while(1) {
          @(posedge gm3.$rxclk); clock_counter = clock_counter + 1;
        }
     } else {
        while(1) {
          @(posedge m3.$rxclk); clock_counter = clock_counter + 1;
        }
     }
 }
}


task pg::config_tx (mii_def port_bind, integer mac_speed ) {
  if(mac_speed == 10000)  port_bind.$rx_config = 4;
  else
    if(mac_speed == 1000)  port_bind.$rx_config = 3;
    else
      if(mac_speed == 100)  port_bind.$rx_config = 2;
      else                   port_bind.$rx_config = 1;

  if(mac_speed == 10000)  port_speed = 4;
  else
    if(mac_speed == 1000)   port_speed = 3;
    else
      if(mac_speed == 100)    port_speed = 2;
      else                    port_speed = 1;


  if(mac_speed == 10000) {  
    port_bind.$rxdv = 1;
  } else {
    port_bind.$rxdv = 0;
  }
  
  port_bind.$rxd = 07;
  port_bind.$rxerr = 0;
  port_bind.$rxcrs = 0;
  port_bind.$rxcol = 0;
}


function bit [31:0]  pg::crc_gen(byte_array p, integer start, integer len) {
  bit [31:0]  tmp0, poly;
  integer i;

  //printf("CRC Function is called \n");

  tmp0 = 32'hffff_ffff;

  for(i=start;i<len;i=i+1) begin   
    tmp0 = crc32_add( p.val[i], tmp0 );
  end   
  tmp0 = ~tmp0;

  
  for(i=0;i<32;i=i+1)
    crc_gen[i] = tmp0[31-i];

  tmp0 = crc_gen;
  crc_gen[31:24] = tmp0[07:00];
  crc_gen[23:16] = tmp0[15:08];
  crc_gen[15:08] = tmp0[23:16];
  crc_gen[07:00] = tmp0[31:24];

}


task pg::status() {
  printf("\n");
  printf("------------------------------\n");
  printf("PG[%0d]: Status Report:\n",my_port);
  printf("        Encountered %0d ERRORS\n",error_count);
  printf("        Encountered %0d WARNINGS\n",warning_count);
  printf("        Sent %0d packets\n",pckt_num);
  printf("------------------------------\n\n");
}





task pg::config(integer what, bit [31:0] data) {
  cfg_reg[what] = data;
}


task pg::print_warn() {
  printf("WARNING: Packet Generator[%0d]: ", my_port);
}


task pg::print_err() {
  printf("ERROR: Packet Generator[%0d] time:%0d : ", my_port, {get_time(HI), get_time(LO)});
}

task pg::display_buf( byte_array buf, integer hwlen, (integer ifedx=0)) {
  integer ptr=0;
  integer tunneling_ipv4 = 0;
  integer tunneling_ipv6 = 0;
  integer ah_transp_ipv4  = 0;
  integer ah_transp_ipv6  = 0;
  integer esp_transp_ipv4 = 0;
  integer esp_transp_ipv6 = 0;
  integer ipv4_header_length;

  integer buf_shift;
  integer n;
  integer i;

  bit [15:0] len;
  bit [7:0] flag_bit;
  bit [79:0] id;
  integer token;

  printf("\n\n______________________________________________________________\n");
  printf("vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv\n\n");


  printf("____________ Hex Dump ____________\n");
  for(n=0;n<hwlen;n++) {
    if( !(n % 16) ) printf("\n%d: ",n);
    printf("%h ", buf.val[ptr++]);
  }
  printf("\n__________________________________\n\n");

  ptr=0;

  printf("   L2 Header\n");
  printf("+---------------\n");
  printf("| Destination Address: %h.%h.%h.%h.%h.%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] ); 
  printf("|      Source Address: %h.%h.%h.%h.%h.%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] ); 

  len = {buf.val[ptr++], buf.val[ptr++]};

  if( len == TPID_8021Q ) {	
    if( {buf.val[ptr+4], buf.val[ptr+5], buf.val[ptr+6]} == LLC_SNAP ) {
      printf("|      L2 Header Type: 802.1Q Tagged LLC-SNAP Ethernet Header\n");
      printf("|                TPID: %0h\n", len );
      printf("|                 TCI: %h\n", {buf.val[ptr++], buf.val[ptr++]} );
      len = {buf.val[ptr++], buf.val[ptr++]}; 
      printf("|            LEN/TYPE: 0x%h(%0d)\n", len, len );
      printf("|                 LLC: %h\n", {buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] });
      printf("|                SNAP: %h\n", {buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } );
      len = {buf.val[ptr - 2], buf.val[ptr - 1]};  
    } else {   // if not LLC SNAP
      printf("|      L2 Header Type: 802.1Q Tagged Ethernet Header\n");
      printf("|                TPID: %0h\n", len );
      printf("|                 TCI: %h\n", {buf.val[ptr++], buf.val[ptr++]} );
      len = {buf.val[ptr++], buf.val[ptr++]}; 
      printf("|            TYPE/LEN: 0x%h(%d)\n", len, len);   
    }
  }/*endifTPID_8021Q*/ else if ( len == CNTL_FRAME )  { 
    printf("|      L2 Header Type:  MAC Control Frame Header\n");
    printf("|                Type: %h\n", len );
  } else { // endif control frame
    if( {buf.val[ptr], buf.val[ptr+1], buf.val[ptr+2]} == LLC_SNAP ) {
      printf("|    L2 Header Type: LLC-SNAP Ethernet Header\n");
      printf("|    Data Length: 0x%h(%0d)\n", len, len);  
      printf("|    LLC: %h\n", {buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] });
      printf("|    SNAP: %h\n", {buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } );
      if( buf.val[ptr-2] == 8'h08 ) {  
        ptr +=20;
        if( buf.val[ptr - 11 ] == TCP_PROTO){
          ptr +=20;
        }
      }
      if( buf.val[ptr-2] == 8'h86 ) {           ptr +=40;
        if( buf.val[ptr - 34 ] == TCP_PROTO){
          ptr +=20;
        }
      }
    } /*endif LLC_SANP*/ else { 
      printf("|      L2 Header Type: 802.3 Ethernet Header\n");
      printf("|    Data Length/Type: 0x%h(%0d)\n", len, len);  
    }
  } // endif!TPID_8021Q

  if( ((buf.val[ptr] & 8'h40)==8'h40 ) & ( (buf.val[ptr] & 8'hf)>5)) {
   
    ipv4_header_length = (buf.val[ptr] & 8'hf);

    token = { buf.val[ptr + ( (4*ipv4_header_length) -20 ) ], buf.val[ptr + ( (4*ipv4_header_length) -20 ) +1] };
  
  } else 
    token = { buf.val[ptr], buf.val[ptr+1] };

  printf(" DEBUG- token - %d \n",token);

  if((len>16'h0600 & len != CNTL_FRAME) || ((len == RARP_FRAME) &(len != CNTL_FRAME))){ 
    len = -1;
// ptr here points to the first byte of ip datagram
    if((buf.val[ptr - 2 ] == 8'h08 ) || (( buf.val[ptr-2] == 8'h80) && (buf.val[ptr-1] == 8'h35))) {  // IP datagram or RARP
      if( buf.val[ptr + 9] == AH_PROTO) { 
        printf("+-------------------------------------\n");
        printf("   L3 Header-- Type: IPv4, IPSec: AH\n");
        printf("+--------------------------------------\n");
        ah_transp_ipv4 = 1;
      } else if( buf.val[ptr + 9] == ESP_PROTO) {  
        printf("+-------------------------------------\n");
        printf("   L3 Header-- Type: IPv4, IPSec: ESP\n");
        printf("+--------------------------------------\n");
        esp_transp_ipv4 = 1;
      } else if( buf.val[ptr + 9] == IP_V4_PROTO) {
        printf("+-------------------------------------\n");
        printf("   L3 Header-- Type: Tunnel (IPv4/IPv4)\n");
        printf("+--------------------------------------\n");
        printf("|   IP Header Tunnel Layer 1: IPv4\n|   \n");   
        tunneling_ipv4 = 1; 
      } else if( buf.val[ptr + 9] == IP_V6_PROTO) {
        printf("+-------------------------------------\n");
        printf("   L3 Header-- Type: Tunnel (IPv4/IPv6)\n");
        printf("+--------------------------------------\n");
        printf("|   IP Header Tunnel Layer 1: IPv4\n|   \n");   
        tunneling_ipv6 = 1; 
      } else {
        printf("+-------------------------------------\n");
        printf("   L3 Header-- Type: IPv4\n");
        printf("+--------------------------------------\n");
      }
      ipv4_header_length = (buf.val[ptr] & 8'hf);
      // printf("DEBUG- ipv4_header_length - %d \n",ipv4_header_length);
      ptr--;
      ptr--;
//ptr here points to type/len field
      display_class(buf, ptr);
// looks like display class increments the ptr to the beginning of IP src address.. 
      
      printf("|   IPV4 Payload Len: %h%h\n", buf.val[ptr-10], buf.val[ptr-9] );
      printf("|   IPV4 Checksum: %h%h\n", buf.val[ptr-2], buf.val[ptr-1] );
      if(ipv4_header_length>5) {
      printf("|   IPV4 Header Length: %d \n", ipv4_header_length);
      }
      printf("|   IP SRC Address: %h.%h.%h.%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
      printf("|   IP DST Address: %h.%h.%h.%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
      for(i=0;i< (ipv4_header_length -5); i ++) {
      printf("|   IP Options: %h.%h.%h.%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
      }
      if (esp_transp_ipv4) {
        printf("|   ESP SPI : %h.%h.%h.%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
      }

      if (ah_transp_ipv4) {
        ptr += 4;
        printf("|   AH SPI : %h.%h.%h.%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
      }
      
      if( tunneling_ipv4 ) {
        printf("|  -----------  \n|\n");   
        printf("|   IP Header Tunnel Layer 2: IPv4:\n");   
        printf("|   \n");   
        ptr--;
        ptr--;
        display_class(buf, ptr);
        printf("|   IP SRC Address: %h.%h.%h.%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
        printf("|   IP DST Address: %h.%h.%h.%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
      } else if( tunneling_ipv6) {
        printf("|  -----------  \n|\n");   
        printf("|   IP Header Tunnel Layer 2: IPv6:\n");   
        printf("|   \n");   
        ptr--;
        ptr--;
        display_class_ipv6(buf, ptr);
        printf("|      Payload Len: 0x%h(%d)\n", buf.val[ptr++], buf.val[ptr++]);
        printf("|      Next Header: 0x%h\n", buf.val[ptr++]);
        printf("|      Hop Limit  : 0x%h\n", buf.val[ptr++]);
        printf("|   IP SRC Address: %h%h:%h%h:%h%h:%h%h:%h%h:%h%h:%h%h:%h%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
               buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
               buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );

        printf("|   IP DST Address: %h%h:%h%h:%h%h:%h%h:%h%h:%h%h:%h%h:%h%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
               buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
               buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
      }

      
      if( tunneling_ipv6 ) 
        buf_shift = 34;       
      else 
        buf_shift = 11  + 4*(ipv4_header_length -5) ;     


      if( buf.val[ptr - buf_shift ] == UDP_PROTO) {
        printf("+-------------------------------------\n");
        printf("   L4 Header-- Type: UDP  \n");
        printf("+--------------------------------------\n");
        printf("|     UDP SRC Port: %h\n", {buf.val[ptr++], buf.val[ptr++]} );
        printf("|     UDP DST Port: %h\n", {buf.val[ptr++], buf.val[ptr++]} );
        printf("|     UDP LEN : %h\n", {buf.val[ptr++], buf.val[ptr++]} );
        printf("|     UDP Chksum : %h\n", {buf.val[ptr++], buf.val[ptr++]} );

	// - ptr here is the first byte of UDP data
        token = { buf.val[ptr + 0], buf.val[ptr + 1] };
        printf(" DEBUG- UDP  token - %d \n",token);

      } else if( buf.val[ptr - buf_shift ] == TCP_PROTO) {
        printf("+-------------------------------------\n");
        printf("   L4 Header-- Type: TCP\n");
        printf("+--------------------------------------\n");
        printf("|     TCP SRC Port: %h\n", {buf.val[ptr++], buf.val[ptr++]} );
        printf("|     TCP DST Port: %h\n", {buf.val[ptr++], buf.val[ptr++]} );
        printf("|   TCP Sequence #: %h\n", {buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++]} );
        printf("|        TCP ACK #: %h\n", {buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++]} );

        ptr += 1;   
        flag_bit = buf.val[ptr++];  
        printf("|    TCP Flag bits: URG:%b ACK:%b PSH:%b RST:%b SYN:%b FIN:%b\n", flag_bit[5], flag_bit[4], flag_bit[3], flag_bit[2], flag_bit[1], flag_bit[0]); 
        printf("|      Window Size: %h\n", {buf.val[ptr++], buf.val[ptr++]});  
        printf("|     TCP Checksum: %h\n", {buf.val[ptr++], buf.val[ptr++]});  

        if(cfg_reg[CFG_TCP_LEN]  > 5 ) { // 
          printf("|      TCP Option : ");
          ptr = ptr + 2;
          for(n=0; n<(cfg_reg[CFG_TCP_LEN]-5); n++) {
            printf("%h%h%h%h ", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++]); 
          }
          printf("\n");
          ptr = ptr - 2;
        } // end if checking option value
        printf("+---------------\n");
	// - ptr here is the first byte of TCP data
        token = { buf.val[ptr + 2], buf.val[ptr+3] };
        printf(" DEBUG- TCP  token ptr - %d  - %d \n",token,ptr);
      }  else if (esp_transp_ipv4) {
        ptr += 8;
        token = { buf.val[ptr], buf.val[ptr+1] };
      } else if (ah_transp_ipv4) {
        ptr += 4;
        token = { buf.val[ptr], buf.val[ptr+1] };
      } else {
        token = { buf.val[ptr], buf.val[ptr+1] };
      } 
    }  /*endif IP datagram or RARP*/ else { /*IPV6*/
      if( buf.val[ptr + 6] == AH_PROTO) {
        printf("+-------------------------------------\n");
        printf("   L3 Header-- Type: IPv6, IPSec: AH\n");
        printf("+--------------------------------------\n");
        ah_transp_ipv6 = 1;
      } else if( buf.val[ptr + 6] == ESP_PROTO) {
        printf("+-------------------------------------\n");
        printf("   L3 Header-- Type: IPv6, IPSec: ESP\n");
        printf("+--------------------------------------\n");
        esp_transp_ipv6 = 1;
      } else if( buf.val[ptr + 6] == IP_V4_PROTO) {
        printf("+-------------------------------------\n");
        printf("   L3 Header-- Type: Tunnel (IPv6/IPv4)\n");
        printf("+--------------------------------------\n");
        printf("|   IP Header Tunnel Layer 1: IPv6\n");
        printf("|   \n");
        tunneling_ipv4 = 1;
      } else if( buf.val[ptr + 6] == IP_V6_PROTO) {
        printf("+-------------------------------------\n");
        printf("   L3 Header-- Type: Tunnel (IPv6/IPv6)\n");
        printf("+--------------------------------------\n");
        printf("|   IP Header Tunnel Layer 1: IPv6\n");
        printf("|   \n");
        tunneling_ipv6 = 1;
      } else {
        printf("+-------------------------------------\n");
        printf("   L3 Header-- Type: IPv6\n");
        printf("+--------------------------------------\n");
      }
      ptr--;
      ptr--;

      display_class_ipv6(buf, ptr);
      printf("|      Payload Len: 0x%h(%d)\n", buf.val[ptr++], buf.val[ptr++]); 
      printf("|      Next Header: 0x%h\n", buf.val[ptr++]); 
      printf("|      Hop Limit  : 0x%h\n", buf.val[ptr++]); 
      printf("|   IP SRC Address: %h%h:%h%h:%h%h:%h%h:%h%h:%h%h:%h%h:%h%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
             buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
             buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
      printf("|   IP DST Address: %h%h:%h%h:%h%h:%h%h:%h%h:%h%h:%h%h:%h%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
             buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
             buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );

      if (esp_transp_ipv6) {
        printf("|   ESP SPI : %h.%h.%h.%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
      }
      if (ah_transp_ipv6) {
        ptr += 4;
        printf("|   AH SPI : %h.%h.%h.%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
      }

      if( tunneling_ipv4 ) {
        printf("|  -----------  \n|\n");   
        printf("|   IP Header Tunnel Layer 2: IPv4:\n");
        printf("|   \n");
        ptr--;
        ptr--;
        display_class(buf, ptr);
        printf("|   IP SRC Address: %h.%h.%h.%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
        printf("|   IP DST Address: %h.%h.%h.%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );

      } else if( tunneling_ipv6) {
        printf("|  -----------  \n|\n");   
        printf("|   IP Header Tunnel Layer 2: IPv6:\n");
        printf("|   \n");
        ptr--;
        ptr--;
        display_class_ipv6(buf, ptr);
        printf("|      Payload Len: 0x%h(%d)\n", buf.val[ptr++], buf.val[ptr++]);
        printf("|      Next Header: 0x%h\n", buf.val[ptr++]);
        printf("|      Hop Limit  : 0x%h\n", buf.val[ptr++]);
        printf("|   IP SRC Address: %h%h:%h%h:%h%h:%h%h:%h%h:%h%h:%h%h:%h%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
               buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
               buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
        printf("|   IP DST Address: %h%h:%h%h:%h%h:%h%h:%h%h:%h%h:%h%h:%h%h\n", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
               buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++],
               buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] );
      }

      if( tunneling_ipv4 )
        buf_shift = 11  + 4*(ipv4_header_length -5) ;     
        // buf_shift = 11;
      else 
        buf_shift = 34;  
      if( buf.val[ptr - buf_shift ] == UDP_PROTO) {
        printf("+-------------------------------------\n");
        printf("   L4 Header-- Type: UDP  \n");
        printf("+--------------------------------------\n");
        printf("|     UDP SRC Port: %h\n", {buf.val[ptr++], buf.val[ptr++]} );
        printf("|     UDP DST Port: %h\n", {buf.val[ptr++], buf.val[ptr++]} );
        printf("|     UDP LEN : %h\n", {buf.val[ptr++], buf.val[ptr++]} );
        printf("|     UDP Chksum : %h\n", {buf.val[ptr++], buf.val[ptr++]} );

        token = { buf.val[ptr + 0], buf.val[ptr + 1] };
      } else if( buf.val[ptr - buf_shift ] == TCP_PROTO) {
        printf("+-------------------------------------\n");
        printf("   L4 Header-- Type: TCP\n");
        printf("+--------------------------------------\n");
        printf("|     TCP SRC Port: %h\n", {buf.val[ptr++], buf.val[ptr++]} );
        printf("|     TCP DST Port: %h\n", {buf.val[ptr++], buf.val[ptr++]} );
        printf("|   TCP Sequence #: %h\n", {buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++]} );
        printf("|        TCP ACK #: %h\n", {buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++]} );
        ptr += 1;   
        flag_bit = buf.val[ptr++];
        printf("|    TCP Flag bits: URG:%b ACK:%b PSH:%b RST:%b SYN:%b FIN:%b\n", flag_bit[5], flag_bit[4], flag_bit[3], flag_bit[2], flag_bit[1], flag_bit[0]); 
        printf("|      Window Size: %h\n", {buf.val[ptr++], buf.val[ptr++]});
        printf("|     TCP Checksum: %h\n", {buf.val[ptr++], buf.val[ptr++]});  
        if(cfg_reg[CFG_TCP_LEN]  > 5 ) {
          printf("|      TCP Option : ");
          ptr = ptr + 2;
          for(n=0; n<(cfg_reg[CFG_TCP_LEN]-5); n++) {
            printf("%h%h%h%h ", buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++]);
          }
          printf("\n");
          ptr = ptr - 2;
        }
        printf("+---------------\n");
        token = { buf.val[ptr + 2], buf.val[ptr+3] };
      }  else if (esp_transp_ipv6) {
        ptr += 8;
        token = { buf.val[ptr], buf.val[ptr+1] };
      } else if (ah_transp_ipv6) {
        ptr += 4;
        token = { buf.val[ptr], buf.val[ptr+1] };
      } else {
        token = { buf.val[ptr], buf.val[ptr+1] };
      }
    }  
  }  /*end if((len>16'h0600 & len != CNTL_FRAME) || ((len == RARP_FRAME) &(len != CNTL_FRAME))) */

  if(len<0)	len = hwlen;

  printf("\npg::display_buf Time: %0d\n",{get_time(HI),get_time(LO)});
  printf("Token: %0d\n", token);
  printf("\n");
  display_data(buf, ptr, hwlen-ptr-4 );
  printf("\n");
  printf("CRC: %h\n", { buf.val[ptr++], buf.val[ptr++], buf.val[ptr++], buf.val[ptr++] } );
  printf("\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
  printf("--------------------------------------------------------------\n\n");

}  


task pg::display_class(byte_array buf, var integer ptr) {
  integer n,last;
  last = ptr+14;
  printf("|              Class: ");
  for(n=0;n<14;n++)	printf("%h ", buf.val[ptr+n] ); 
  printf("\n");
  if( {buf.val[ptr], buf.val[ptr+1]} < 16'h0600)
    printf("|             Length: %0d\n|\n", {buf.val[ptr++], buf.val[ptr++]} );
  else
    printf("|               Type: %0h\n|\n", {buf.val[ptr++], buf.val[ptr++]} );
  ptr=last;
}


task pg::display_class_ipv6(byte_array buf, var integer ptr) {
  integer n,last;

  last = ptr+6;

  printf("|              Class: ");

  
  for(n=0;n<10;n++)       printf("%h ", buf.val[ptr+n] );
  printf("\n");

  if( {buf.val[ptr], buf.val[ptr+1]} < 16'h0600)
    printf("|             Length: %0d\n|\n", {buf.val[ptr++], buf.val[ptr++]} );
  else
    printf("|               Type: %0h\n|\n", {buf.val[ptr++], buf.val[ptr++]} );

  ptr=last;
}



task pg::display_data(byte_array buf, var integer ptr, integer len) {
  integer n;

  printf("    Data:\n");
  printf("+---------------");

  if(len<1)
    printf("\n| No Payload ...");
  else

    for(n=0;n< len ;n++) {
      if( !(n % 16) ) printf("\n| %d: ",n);
      printf("%h ", buf.val[ptr++]);
    }
  printf("\n+---------------\n");
}


task pg::display_id(bit [79:0] id) {

  printf("    ID Tags:\n");
  printf("+---------------\n");
  printf("|       Src port: %0d\n", id[79:75] );
  printf("|       Dst port: %0h\n", id[74:35] );
  printf("|     Order Type: %0h\n", id[34:33] );
  printf("|  Order Sequnce: %0d\n", id[32:27] );
  printf("|  Packet number: %0d\n", id[26:11] );
  printf("|      Data Type: %0d\n", id[10:8] );
  printf("|      Data Seed: %0d\n", id[7:0] );
  printf("+---------------\n");
}


task pg::display_db(pack_db_entry pack_db ) {

  printf("\n========== Display DB Entry %0d ========== \n",pack_db.gId);
  if(pack_db == null) {
    printf("This entry is not allocated ...\n");
  } else {

    printf("\tframe.frame_type:  %h\n",pack_db.frame.frame_type);
    printf("\tframe.frame_class: %h\n",pack_db.frame.frame_class);
    printf("\tframe.class_mask:  %h\n",pack_db.frame.class_mask);
    printf("\tframe.class_funct: %h\n",pack_db.frame.class_funct);
    printf("\tframe.data_type:   %h\n",pack_db.frame.data_type);
    printf("\tframe.data_seed:   %h\n",pack_db.frame.data_seed);
    printf("\tframe.data_length: %h\n",pack_db.data_length);
    printf("\n");
    printf("\tsrc_node.l2_addr: %h\n",pack_db.src_node.l2_addr);
    printf("\tsrc_node.tci:     %h\n",pack_db.src_node.tci);
    printf("\tsrc_node.ip_addr: %h\n",pack_db.src_node.ip_addr);
    printf("\tsrc_node.ipv6_addr: %h\n",pack_db.src_node.ipv6_addr);
    printf("\n");
    printf("\tdst_node.l2_addr: %h\n",pack_db.dst_node.l2_addr);
    printf("\tdst_node.tci:     %h\n",pack_db.dst_node.tci);
    printf("\tdst_node.ip_addr: %h\n",pack_db.dst_node.ip_addr);
    printf("\tdst_node.ipv6_addr: %h\n",pack_db.dst_node.ipv6_addr);
    printf("\n");
    printf("\ttup.src_tcp_udp_port: %h\n",pack_db.tup.src_tcp_udp_port);
    printf("\ttup.dst_tcp_udp_port: %h\n",pack_db.tup.dst_tcp_udp_port);
    printf("\n");
    printf("\trcv_isn: %0h\n",pack_db.rx_param.rcv_isn);
    printf("\tlast_ackno: %0h\n",pack_db.rx_param.last_ackno);
    printf("\tadv_isn: %0h\n",pack_db.tx_param.adv_isn);
    printf("\tlast_seqno: %0h\n",pack_db.tx_param.last_seqno);
    printf("\n");
    printf("\torg_port:  %0d\n",pack_db.org_port);
    printf("\torder_seq: %0d\n",pack_db.order_seq);
    printf("\tpckt_num:  %0d\n",pack_db.pckt_num);
    printf("\toptions:   %h\n",pack_db.options);
  }
  printf("========================================== \n\n");
}

task pg::display_flow(integer flow_id) {

  printf("\n========== Display FLOW DB Entry %0d ========== \n",flow_id);
  if(flow_db[flow_id] == null) {
    printf("This entry is not allocated ...\n");
  } else {
    printf("\tframe.data_length: %h\n",flow_db[flow_id].data_length);
    printf("\n");
    printf("\ttup.src_tcp_udp_port: %h\n",flow_db[flow_id].tup.src_tcp_udp_port);
    printf("\ttup.dst_tcp_udp_port: %h\n",flow_db[flow_id].tup.dst_tcp_udp_port);
    printf("\n");
    printf("\torg_port:  %0d\n",flow_db[flow_id].org_port);
    printf("\trcv_isn: %0h\n",flow_db[flow_id].rx_param.rcv_isn);
    printf("\tlast_ackno: %0h\n",flow_db[flow_id].rx_param.last_ackno);
    printf("\tadv_isn: %0h\n",flow_db[flow_id].tx_param.adv_isn);
    printf("\tlast_seqno: %0h\n",flow_db[flow_id].tx_param.last_seqno);
    
    
  }
  printf("========================================== \n\n");
}


function bit[15:0] pg::partial_cksum(byte_array packet, integer start_offset, integer pkt_len) {
 
  integer i; 
  bit [16:0] chksum_tmp = 0;

     for(i = start_offset; i < pkt_len;)
      {
        if(i == pkt_len - 1) {
           chksum_tmp = chksum_tmp + {packet.val[i],8'h0};
           chksum_tmp = chksum_tmp + chksum_tmp[16];
           chksum_tmp[16] = 1'b0;
        } else {
           chksum_tmp = chksum_tmp + {packet.val[i],packet.val[i+1]};
           chksum_tmp = chksum_tmp + chksum_tmp[16];
           chksum_tmp[16] = 1'b0;
        }
           i = i+2;
      }

   partial_cksum = chksum_tmp[15:0];

}