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

#include "niu_dma.vrh"
#include "pcg_token.vrh"
#include "niu_txtoken.vrh"
#include "niu_txcntrl_wd.vrh"
#include "niu_tx_pktconfig.vrh"
#include "niu_tx_descp.vrh"
#include "cMesg.vrh"
#include "pgIdgen.vrh"



extern CSparseMem SparseMem;
extern mbox_class mbox_id;
extern Mesg     be_msg;

extern niu_gen_pio gen_pio_drv;

function  byte_array DMAChannel::generate_packets(TxPacketGenConfig PktGenConfig,CTxToken  TxToken ) {


	byte_array packets;
	integer mac_id;
	integer d;
  	integer token;
	integer port_id;
	integer i;
	CpgToken pgToken;
        integer LLC_HACK = 1;
	bit [15:0] llc_length;
	integer status;




        if(PktGenConfig.error_info.hosterrors.dma_errors == NACK_PREF_ERROR) {
          is_nack_pref_err = 1;
          nack_pref_err_addr = TxToken.xlate_desc_addr;
          nack_pref_err_pcaddr = TxToken.xlate_desc_addr - 64'h40;
        }
	
	status = SetTxError.set_up_errors(PktGenConfig,TxToken);
	if(status) do_not_check_packet = 1;

	mac_id = PktGenConfig.mac_id ;
	packets =  new();


	printf(" Generating Packets for DMA id %d , data_length = %d \n",id,PktGenConfig.data_length);
        if (get_plus_arg (CHECK, "RX_DROP_PKT_CHECK")) {
         printf("RX_DROP_PKT_CHECK is specified. MAC-SA before replacing 0x%h\n", PktGenConfig.flow.src_node.l2_addr);
         // modify src address for the drop checker 
  	 // This is to be used only for loopback cases
         PktGenConfig.flow.src_node.l2_addr = pgIdgen.getMacSA(PktGenConfig.loop_back_rxdma_num,mac_id);
         printf("RX_DROP_PKT_CHECK is specified. MAC-SA after replacing 0x%h\n", PktGenConfig.flow.src_node.l2_addr);
        } else
         PktGenConfig.flow.src_node.l2_addr = pgIdgen.getMacSA(id,mac_id);

	// Need some config info which indicates the type of packets to generate
 	pack_gen[mac_id + 8].pkt_gen( PktGenConfig.flow,PktGenConfig.data_length, 3, pgToken, O_WAIT_SEND_FAKE | O_FAKE_OUT );
        printf(" data_len - %d \n",pgToken.pack_db.data_length);
        printf(" header len - %d \n",pgToken.pack_db.header_len[0]);
        token = pgToken.gId;

  // Copy header to out_header in pack_db
       pgToken.pack_db.out_header[mac_id ] = new;
       pgToken.pack_db.out_header[mac_id ].use_header = 0;
       pgToken.pack_db.out_header[mac_id ].header[0] = new;
       pgToken.pack_db.out_header[mac_id ].header_len[0] = pgToken.pack_db.header_len[ pgToken.pack_db.use_hdr ];
       


       for( i = 0; i < pgToken.pack_db.out_header[mac_id ].header_len[0]; i++ )
          pgToken.pack_db.out_header[mac_id].header[0].val[i] = 
            pgToken.pack_db.header[ pgToken.pack_db.use_hdr ].val[i];

// NEW PACKET
#ifdef MAC_SAT
#else
        packets = new pgToken.buf;
#endif
	TxToken.pgToken  = new pgToken;
	TxToken.pgToken.exp_err  = PktGenConfig.err_pkt;

        if(PktGenConfig.ecc_2biterr_line1)
	  TxToken.pgToken.do_not_check  = do_not_check_packet || PktGenConfig.err_pkt;
        else 
	  TxToken.pgToken.do_not_check  = do_not_check_packet;

	TxToken.pgToken.tx_dma_id  = id;
	printf("Err DEBUG ID - %d Flag - %d \n",TxToken.pgToken.gId,do_not_check_packet);
	printf("Err DEBUG ID - %d Flag - %d \n",TxToken.pgToken.gId,TxToken.pgToken.do_not_check);

        printf("gen_pkts : value of exp_err %0d\n",TxToken.pgToken.exp_err);




       printf("################## BEFORE HOSTPKT DISPLAY\n");
   
       if (get_plus_arg(CHECK,"TX_VERBOSE")) {
         pack_gen[mac_id + 8].display_buf(packets,PktGenConfig.data_length);
       }


	if(tx_port_num == -1) {
	  printf("ERROR- TxPort Not Bound for DMA Channel Id -%d \n",id);
	} else {
	  port_id = tx_port_num;
         // Only for MAC loop back 
	  TxToken.loop_back_rxdma_num =  PktGenConfig.loop_back_rxdma_num;
	  TxToken.loop_back_rx_lastpacket =  PktGenConfig.loop_back_rx_lastpacket;
	  generate_tokens(port_id,token,TxToken);
	}

	generate_packets = packets;

}



task DMAChannel::gen_txpacket(integer ii,TxPacketGenConfig PktGenConfig) {

/*

	ip_packets = generate_packet(config);

	noofdescs = check_how_many_descriptors_for_this_packet;
	for(i=0;i<noofdescs;i++) {
	get_address();
	write_packet_into_memory;
	create_descriptors;
	add_descriptors(r);
	}
	generate_tokens;
	
*/


	TxPacketControlWord control_word;
	CTxdescriptor desc;
        bit[43:0] address;
	integer noofdescs;
	bit [13:0] pkt_length;
        integer rem_pkt_length;
	integer i;
	byte_array packets;
	bit [127:0] w;
	byte_array ip_packets;
        integer pkt_ptr;
        integer last_pkt_ptr;
        integer buf_sz;
	bit [3:0] num_ptr;
	bit [95:0] debug_mac_hdr_bits;
        bit [39:0] phy_addr;
        bit [39:0] desc_phy_addr;
        bit [39:0] desc_v_addr;
        bit [39:0] mbox_phy_addr;

        integer pad;
        integer mac_id;

	integer pkt_page_id;
        integer pageid = -1; // default to give random page_id
        integer chksum_enb;
        bit [15:0] partial_chk_sum;
        bit[43:0] st_addr_4ka;
        bit[43:0] end_addr_4ka;
        integer done = 0;
        integer offset16B = 0;

	CTxToken TxToken;
	
	TxToken = new(); // Uninitialized

	TxToken.dma_num = id;
	TxToken.port_num  = tx_port_num;

        pad = PktGenConfig.pad;
        mac_id = PktGenConfig.mac_id;
	pkt_length = PktGenConfig.data_length  + PktGenConfig.flow.frame.l2_pad_length - 4;

	TxToken.pkt_length  = pkt_length + 2*pad;

        // get the buffsize from command line

	if (get_plus_arg (CHECK,"TX_BUFFSZ"))
	   buf_sz = get_plus_arg(NUM,"TX_BUFFSZ");
	else
           buf_sz = 128;

        // plus arg for a particular page_id

         if (get_plus_arg (CHECK,"PAGE_ID"))
            pageid = get_plus_arg(NUM,"PAGE_ID");

         if (get_plus_arg (CHECK,"CHKSUM_ENB"))
            chksum_enb = get_plus_arg(NUM,"CHKSUM_ENB");
         else 
            chksum_enb = 0;

         if(pageid == 0) 
            pkt_page_id = page0_id;
         else if(pageid == 1) 
            pkt_page_id = page1_id;
         else {
            // randomize the pageid
            pkt_page_id = random()%2 ? page1_id : page0_id;
         }
            

        // based on the gather mode do the following

       // hack untill clean up happens to code below

	if((PktGenConfig.gConfig_mode!=0) ) {
	  gen_txGatherPackets( PktGenConfig,pkt_page_id  );
        }  else {
        

        if(gather_mode || PktGenConfig.g_mode) {
		noofdescs = (pkt_length + 16)%buf_sz ? 
                            (pkt_length +16)/buf_sz + 1 :
		            (pkt_length + 16)/buf_sz;
	} else  noofdescs = 1;

	printf("Num of desc used %d\n",noofdescs);

        num_ptr = noofdescs;
        TxToken.NoofGathers = noofdescs;

	for(i=0;i<noofdescs;i++) {

           done = 0;

           if (get_plus_arg (CHECK, "USE_RANDOM_ADDRESS")) {
             if(i==0) {
	         address = SparseMem.get_address(1,pkt_page_id,16);//10Blocks -- 10*block_size = 5120B 
             } else {
	         address = SparseMem.get_address(1,pkt_page_id,64);//10Blocks -- 10*block_size = 5120B 
             }
	        // address = address + 9'h1ff - address[8:0] + 1;
	 // To make this address 64byte aligned
	   } else {
		address = 44'h0_03456000 + ii*2048 + id*32'h10_0000 + i*buf_sz;
	   }
         TxToken.xlate_gather_address[i] = SparseMem.xlate_addr( address[39:0], pkt_page_id );


	if(i==0) {
	 if( get_plus_arg (CHECK,"ENABLE_MAC_HDR_DEBUG") ) {
	   debug_mac_hdr_bits = gen_debug_header( address, desc_ring.ring_current_addr, pkt_length /*MORE FIELDS TO BE ADDED*/  );
	   printf(" DEBUG - MAC_ HEADER - %x \n",debug_mac_hdr_bits);

  	   PktGenConfig.flow.src_node.l2_addr = debug_mac_hdr_bits[47:0];
  	   PktGenConfig.flow.dst_node.l2_addr = debug_mac_hdr_bits[95:48];
	  }

            // get the descriptor virtual & phy address
            desc_v_addr = desc_ring.ring_start_addr + desc_ring.ring_current_addr;
            desc_phy_addr = SparseMem.xlate_addr(desc_v_addr,desc_ring.ring_page_id,0);
         
            // get ohy address of the mailbox addr
            mbox_phy_addr = SparseMem.xlate_addr(mailbox_addr,desc_ring.ring_page_id,0);
          
          // code to induce pkt_part_err (this is translation erro for pkt_address)
          // if(PktGenConfig.error_info.hosterrors.packet_errors == PKT_PART_ERROR) 
          if(PktGenConfig.err_code == PKT_PART_ERROR) {
             address =  address ^ 44'hfff_ffff_ffff;
             do_not_check_packet = 1;
             TxToken.pgToken.do_not_check  = do_not_check_packet;
             printf("Inducing PKT_PART_ERR\n");
          } 
        
          
	  TxToken.packet_start_address = address;
          TxToken.descriptor_address = desc_ring.ring_current_addr;
 	  TxToken.xlate_desc_addr = desc_phy_addr;
 	  TxToken.xlate_mb_addr = mbox_phy_addr;

          if(noofdescs == 1)
             TxToken.last_descriptor_address = desc_ring.ring_current_addr;

          TxToken.print();

	  ip_packets = generate_packets(PktGenConfig,TxToken);
          
            // Check if TCP pkt
            if((PktGenConfig.flow.frame.frame_class == CL_TCP) || (PktGenConfig.flow.frame.frame_class == CL_TCP_IP_V6) || (PktGenConfig.flow.frame.frame_class == CL_UDP) || (PktGenConfig.flow.frame.frame_class == CL_UDP_IP_V6)) {
               stuff_psu_hdr_chksum(ip_packets,PktGenConfig);
           }

          // display the pseudo hdr stuffed buffer

          // pack_gen[mac_id + 8].display_buf(ip_packets,PktGenConfig.data_length);
	}

         if(i==0) {
		if(gather_mode || PktGenConfig.g_mode) {

		control_word = new(i);

                if(PktGenConfig.set_wrong_ctlwd)
		  w = 128'h0;
		else
                  w = control_word.format_ctrl_word(PktGenConfig);

		control_word.set_control_word(w);

		pkt_ptr = 0;
		 if((pkt_length + 16) <= buf_sz) {
                   if(PktGenConfig.mark_bit)
		     create_descriptor(desc,pkt_length + 16 + 2*pad ,address,num_ptr,1,1,pkt_page_id);
                   else
		     create_descriptor(desc,pkt_length + 16 + 2*pad ,address,num_ptr,1,0,pkt_page_id);

		TxToken.gather_pkt_length[i] = desc.tr_len;
		WriteTxControlWord(address,control_word,pkt_page_id);
		address = address + 16 + pad*2; // 128 bits of internal packet_header
		WritePackets(ip_packets,address,pkt_length,pkt_ptr,last_pkt_ptr,pkt_page_id);
		 } else {
                   if(PktGenConfig.mark_bit)
		     create_descriptor(desc,buf_sz,address,num_ptr,1,1,pkt_page_id);
                   else
		     create_descriptor(desc,buf_sz,address,num_ptr,1,0,pkt_page_id);
		TxToken.gather_pkt_length[i] = desc.tr_len;
		WriteTxControlWord(address,control_word,pkt_page_id);
		address = address + 16 + pad*2; // 128 bits of internal packet_header
		WritePackets(ip_packets,address,(buf_sz-16),pkt_ptr,last_pkt_ptr,pkt_page_id);
		rem_pkt_length = (pkt_length +16) - buf_sz;
              }
		desc_ring.add_descriptor(desc);
		pkt_ptr = last_pkt_ptr;
		} else {
		 control_word = new(i);
		 pkt_ptr = 0;
	         w = control_word.format_ctrl_word(PktGenConfig);
		 control_word.set_control_word(w);
                   if(PktGenConfig.mark_bit)
		     create_descriptor(desc,pkt_length + 16 + 2*pad ,address,num_ptr,1,1,pkt_page_id);
                   else
		     create_descriptor(desc,pkt_length + 16 + 2*pad ,address,num_ptr,1,0,pkt_page_id);
		TxToken.gather_pkt_length[i] = desc.tr_len;
		 WriteTxControlWord(address,control_word,pkt_page_id);
		 address = address + 16 + pad*2;
		 WritePackets(ip_packets,address,pkt_length,pkt_ptr,last_pkt_ptr,pkt_page_id);
		 desc_ring.add_descriptor(desc);
		 pkt_ptr = last_pkt_ptr;
		 rem_pkt_length = 0;
              }
          } else {
		if(rem_pkt_length <= buf_sz) {
		  create_descriptor(desc,rem_pkt_length,address,num_ptr,0,0,pkt_page_id);
		  TxToken.gather_pkt_length[i] = desc.tr_len;
		  WritePackets(ip_packets,address,rem_pkt_length,pkt_ptr,last_pkt_ptr,pkt_page_id);
		  rem_pkt_length = rem_pkt_length - buf_sz;
                  // update the last descriptor address of the pkt 
 	          TxToken.last_descriptor_address = desc_ring.ring_current_addr;
                  printf("last_desc of token %d is %h\n",TxToken.id,TxToken.last_descriptor_address);
		  desc_ring.add_descriptor(desc);
		  PktGenConfig.g_mode = 0;
		} else {
		  create_descriptor(desc,buf_sz,address,num_ptr,0,0,pkt_page_id);
		  TxToken.gather_pkt_length[i] = desc.tr_len;
		  WritePackets(ip_packets,address,buf_sz,pkt_ptr,last_pkt_ptr,pkt_page_id);
		  rem_pkt_length = rem_pkt_length - buf_sz;
		  desc_ring.add_descriptor(desc);
                }
		// printf("Remainder_pkt_len %d\n",rem_pkt_length);
		pkt_ptr=last_pkt_ptr;
          }
		printf("Remainder_pkt_len %d\n",rem_pkt_length);

     }

  }// else for hack code
}

// New code for gather packet generation

task DMAChannel::gen_txGatherPackets(TxPacketGenConfig PktGenConfig, (integer pkt_page_id=0)) {



	TxPacketControlWord control_word;
	CTxdescriptor desc;
        bit[43:0] address;
	integer noofdescs;
	bit [13:0] pkt_length;
        integer rem_pkt_length;
	integer i;
	byte_array packets;
	bit [127:0] w;
	byte_array ip_packets;
        integer pkt_ptr;
        integer last_pkt_ptr;
        integer buf_sz;
	bit [3:0] num_ptr;
        bit [3:0] offset;
	bit [95:0] debug_mac_hdr_bits;
        integer pad;
        bit[43:0] st_addr_4ka;


	CTxToken TxToken;
	
	TxToken = new(); // Uninitialized

	TxToken.dma_num = id;
	TxToken.port_num  = tx_port_num;

        pad = PktGenConfig.pad;
	pkt_length = PktGenConfig.data_length + PktGenConfig.flow.frame.l2_pad_length  - 4;

	TxToken.pkt_length  = pkt_length + 2*pad;


	if(PktGenConfig.gConfig_mode == -1) {
	  PktGenConfig.SetGatherFields();
	  PktGenConfig.printGatherFields();
        }
        noofdescs = PktGenConfig.gConfig_noOfDesc;

	printf("DMAChannel::gen_txGatherPackets Num of desc to beused %d\n",noofdescs);

	// ifset in random mode, populate gConfig_length and gConfig_alignment fields


        num_ptr = noofdescs;
        TxToken.NoofGathers = noofdescs;
	for(i=0;i<noofdescs;i++) {

           if (get_plus_arg (CHECK, "USE_RANDOM_ADDRESS")) {
             if(i==0)
	        address = SparseMem.get_address(1,pkt_page_id,PktGenConfig.gConfig_alignment[i]);//10Blocks -- 10*block_size = 5120B 
             else {
                   if(PktGenConfig.gConfig_specific_alignment) {
		    st_addr_4ka = SparseMem.get_address(2,pkt_page_id,4096); 
                    address = st_addr_4ka + PktGenConfig.gConfig_specific_line*16 +PktGenConfig.gConfig_alignment[i];
                   } else {

	            address = SparseMem.get_address(1,pkt_page_id,PktGenConfig.gConfig_alignment[i]);//10Blocks -- 10*block_size = 5120B 
                    offset = address[3:0];
                    be_msg.print(e_mesg_info,"niu_tx_descp","gather_waddr_offset","BYTE_ADDR_OFFSET %0h\n",offset);
                   }
                  }
                    
	        // address = address + 9'h1ff - address[8:0] + 1;
	 // To make this address 64byte aligned
	   }

         TxToken.xlate_gather_address[i] = SparseMem.xlate_addr( address[39:0], pkt_page_id );


	if(i==0) {
	 if( get_plus_arg (CHECK,"ENABLE_MAC_HDR_DEBUG") ) {
	   debug_mac_hdr_bits = gen_debug_header( address, desc_ring.ring_current_addr, pkt_length /*MORE FIELDS TO BE ADDED*/  );
	   printf(" DEBUG - MAC_ HEADER - %x \n",debug_mac_hdr_bits);

  	   PktGenConfig.flow.src_node.l2_addr = debug_mac_hdr_bits[47:0];
  	   PktGenConfig.flow.dst_node.l2_addr = debug_mac_hdr_bits[95:48];
	  }

	  TxToken.packet_start_address = address;
 	  TxToken.descriptor_address = desc_ring.ring_current_addr;
          TxToken.print();
	  ip_packets = generate_packets(PktGenConfig,TxToken);
 
          if(noofdescs == 1)
             TxToken.last_descriptor_address = desc_ring.ring_current_addr;

          
            // Check if TCP pkt
            if((PktGenConfig.flow.frame.frame_class == CL_TCP) || (PktGenConfig.flow.frame.frame_class == CL_TCP_IP_V6) || (PktGenConfig.flow.frame.frame_class == CL_UDP) || (PktGenConfig.flow.frame.frame_class == CL_UDP_IP_V6)) {
		stuff_psu_hdr_chksum(ip_packets,PktGenConfig);
	   }

	}

         if(i==0) {
		pkt_ptr = 0;
		control_word = new(i);
	        w = control_word.format_ctrl_word(PktGenConfig);
		control_word.set_control_word(w);
                if(PktGenConfig.mark_bit)
		   create_descriptor(desc,PktGenConfig.gConfig_length[i] + 16 + 2*pad,address,num_ptr,1,1,pkt_page_id);
                else
		   create_descriptor(desc,PktGenConfig.gConfig_length[i] + 16 + 2*pad,address,num_ptr,1,0,pkt_page_id);
		TxToken.gather_pkt_length[i] = desc.tr_len;
		WriteTxControlWord(address,control_word,pkt_page_id);
		address = address + 16 + 2*pad; // 128 bits of internal packet_header
		WritePackets(ip_packets,address,PktGenConfig.gConfig_length[i],pkt_ptr,last_pkt_ptr,pkt_page_id);
		desc_ring.add_descriptor(desc);
		pkt_ptr = last_pkt_ptr;
		
          } else {
		  create_descriptor(desc,PktGenConfig.gConfig_length[i],address,num_ptr,0,0,pkt_page_id);
		  TxToken.gather_pkt_length[i] = desc.tr_len;
		  WritePackets(ip_packets,address,PktGenConfig.gConfig_length[i],pkt_ptr,last_pkt_ptr,pkt_page_id);
 	          TxToken.last_descriptor_address = desc_ring.ring_current_addr;
                  printf("last_desc of token %d is %h\n",TxToken.id,TxToken.last_descriptor_address);
		  desc_ring.add_descriptor(desc);
		  PktGenConfig.g_mode = 0;
		  pkt_ptr=last_pkt_ptr;
          }

     }

}


//-- task to calulate partial checksum with zeros in the stuff field

function bit[15:0] DMAChannel:: partial_cksum(byte_array ip_packets, TxPacketGenConfig PktGenConfig, integer
index) {

  integer i,j;
  bit [16:0] chksum_tmp = 16'h0;
  integer len;
  integer l4_start;
  bit [15:0] tmp_pchksum;
  integer fclass;

  fclass = PktGenConfig.flow.frame.frame_class;

  if((fclass == CL_TCP) || (fclass == CL_TCP_IP_V6)) 
    l4_start = index - 16; // this is because index points to the chksum bytes
  else if((fclass == CL_UDP) || (fclass == CL_UDP_IP_V6))
    l4_start = index - 6; // this is because index points to the chksum bytes

  len = PktGenConfig.data_length + PktGenConfig.flow.frame.l2_pad_length  - 4;

  ip_packets.val[index] = 8'h0;
  ip_packets.val[index+1] = 8'h0;

  printf("partial_cksum : index %0d\n",index);
  printf("partial_cksum : l4_start %0d\n",l4_start);
  printf("partial_cksum : len %0d\n",len);

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

   tmp_pchksum = chksum_tmp[15:0];

   partial_cksum = ~({tmp_pchksum[7:0],tmp_pchksum[15:8]});

}
 


//-- task to stuff psuedo header checksum

task DMAChannel:: stuff_psu_hdr_chksum(byte_array ip_packets, TxPacketGenConfig PktGenConfig)
{

  integer hdr_len = PktGenConfig.flow.frame.header_length;
  integer index;
  integer index_base;
  bit ipver;
  bit [15:0] full_chksum;
  bit [15:0] tmp;

  bit [15:0] partial_chksum;
  bit [15:0] psd_hdr_chksum;
  bit [15:0] inv_psd_hdr_chksum;

  ipver = PktGenConfig.flow.frame.frame_type[3];
  index_base = get_index_base(PktGenConfig); 

  if(ipver == 1'b0) {
      index = index_base + (hdr_len - 5)*4;
  } else {
      index = index_base;
  }

  full_chksum = {ip_packets.val[index+1],ip_packets.val[index]};

  printf("stuff : full_cksum : value of full_chksum %0h\n",full_chksum);

  partial_chksum = partial_cksum(ip_packets,PktGenConfig,index);

  printf("stuff : partial_cksum : value of partial_chksum %0h\n",partial_chksum);

  if(full_chksum > partial_chksum) 
    psd_hdr_chksum = full_chksum - partial_chksum;
  else { 
    tmp = full_chksum - 1;
    psd_hdr_chksum = {1'b1,tmp} - partial_chksum;
  } 
  
  
  printf("stuff : partial_cksum : value of psd_hdr_chksum %0h\n",psd_hdr_chksum);

  inv_psd_hdr_chksum = ~psd_hdr_chksum;

  printf("stuff : partial_cksum : value of inv_psd_hdr_chksum %0h\n",inv_psd_hdr_chksum);

  ip_packets.val[index] = inv_psd_hdr_chksum[7:0];
  ip_packets.val[index+1] = inv_psd_hdr_chksum[15:8];

}

//--- function to calculate the index base value

function integer  DMAChannel:: get_index_base(TxPacketGenConfig PktGenConfig)
{
   integer base;
   integer fclass;
   bit vlan;
   bit llc;
   bit ipver;

   ipver = PktGenConfig.flow.frame.frame_type[3];
   vlan = PktGenConfig.flow.frame.frame_type[2];
   llc = PktGenConfig.flow.frame.frame_type[0];
   fclass = PktGenConfig.flow.frame.frame_class;

   if(ipver == 1'b0) {
    if(fclass == CL_TCP) {
	case({llc,vlan}) {
           2'b00 : base = 50;
           2'b01 : base = 54;
           2'b10 : base = 58;
           2'b11 : base = 62;
        }
    } else if(fclass == CL_UDP) {
	case({llc,vlan}) {
           2'b00 : base = 40;
           2'b01 : base = 44;
           2'b10 : base = 48;
           2'b11 : base = 52;
        }
     }
   } else {
    if(fclass == CL_TCP_IP_V6) {
	case({llc,vlan}) {
           2'b00 : base = 70;
           2'b01 : base = 74;
           2'b10 : base = 78;
           2'b11 : base = 82;
        }
    } else if(fclass == CL_UDP_IP_V6) {
	case({llc,vlan}) {
           2'b00 : base = 60;
           2'b01 : base = 64;
           2'b10 : base = 68;
           2'b11 : base = 72;
        }
     }
  }
     
    get_index_base = base;
}