/// size 14 bytes

logic  [7:0] ether_hdr_da[5:0];              // destination MAC address
logic  [7:0] ether_hdr_sa[5:0];              // source MAC address
logic  [7:0] ether_hdr_type_code[1:0];     // type code - 0x0800 is IP      

/// size 20 bytes    

logic  [7:0] ip_hdr_ver_hlen;                // version - 4 bits;  IP hdr len - 4 bits // IPv4 with 20 byte header 0x45  
logic  [7:0] ip_hdr_tos;                     // Type of service
logic  [7:0] ip_hdr_tlen[1:0];                // Size of datagram (header + data)
logic  [7:0] ip_hdr_id[1:0];                 // together with sa, uniequly identifies pkt
logic  [7:0] ip_hdr_frag_off[1:0];            // flags - 3 bits; fragment offset - 13 bits
logic  [7:0] ip_hdr_ttl;                    // time to live
logic  [7:0] ip_hdr_proto;                    // protocol UDP_PROTO    0x11
logic  [7:0] ip_hdr_csum[1:0];                // header checksum
logic  [7:0] ip_hdr_sa[3:0];                // IP source address
logic  [7:0] ip_hdr_da[3:0];                // IP dest address                            

/// size 8 bytes

logic [7:0]  udp_hdr_sp[1:0];                 // Source port             
logic [7:0]  udp_hdr_dp[1:0];                // Destination port         
logic [7:0]  udp_hdr_len[1:0];                 // length of packet
logic [7:0]  udp_hdr_csum[1:0];             // checksum

  always_comb begin
    case (cnt_words_tx)
        0: aso_out0_data = {        ether_hdr_da[5],            ether_hdr_da[4],            ether_hdr_da[3],        ether_hdr_da[2]    };
        1: aso_out0_data = {        ether_hdr_da[1],            ether_hdr_da[0],            ether_hdr_sa[5],        ether_hdr_sa[4]    };
        2: aso_out0_data = {        ether_hdr_sa[3],            ether_hdr_sa[2],            ether_hdr_sa[1],        ether_hdr_sa[0]    };
        3: aso_out0_data = {        ether_hdr_type_code[1],     ether_hdr_type_code[0],    ip_hdr_ver_hlen,        ip_hdr_tos            };
        4: aso_out0_data = {     ip_hdr_tlen[1],            ip_hdr_tlen[0],            ip_hdr_id[1],            ip_hdr_id[0]        };
        5: aso_out0_data = {        ip_hdr_frag_off[1],        ip_hdr_frag_off[0],        ip_hdr_ttl,                ip_hdr_proto        };
        6: aso_out0_data = {        ip_hdr_csum[1],            ip_hdr_csum[0],            ip_hdr_sa[3],            ip_hdr_sa[2]        };
        7: aso_out0_data = {        ip_hdr_sa[1],                ip_hdr_sa[0],                ip_hdr_da[3],            ip_hdr_da[2]        };
        8: aso_out0_data = {        ip_hdr_da[1],                ip_hdr_da[0],                udp_hdr_sp[1],            udp_hdr_sp[0]        };
        9: aso_out0_data = {        udp_hdr_dp[1],                udp_hdr_dp[0],                udp_hdr_len[1],        udp_hdr_len[0]        };
      10: aso_out0_data = {        udp_hdr_csum[1],            udp_hdr_csum[0],            aso_out0_data_tx[31:16]};
        
        default: aso_out0_data = aso_out0_data_tx;
    endcase
end

logic  [7:0] ip_hdr_ver_hlen;                // version - 4 bits;  IP hdr len - 4 bits // IPv4 with 20 byte header 0x45
logic  [7:0] ip_hdr_tos;                     // Type of service
logic  [7:0] ip_hdr_tlen[1:0];                // Size of datagram (header + data)
logic  [7:0] ip_hdr_id[1:0];                 // together with sa, uniequly identifies pkt
logic  [7:0] ip_hdr_frag_off[1:0];            // flags - 3 bits; fragment offset - 13 bits
logic  [7:0] ip_hdr_ttl;                    // time to live
logic  [7:0] ip_hdr_proto;                    // protocol UDP_PROTO    0x11
logic  [7:0] ip_hdr_csum[1:0];                // header checksum

localparam    SIZE_ETHER_HDR        = 14;
localparam    SIZE_IP_HDR            = 20;
localparam    SIZE_UDP_HDR        = 8;

  
localparam    UDP_PROTO            = 8'h11;
localparam    ETH_TYPE                = 16'h0800;
localparam    IP_VER                = 8'h45;
localparam    IP_TTL                = 8'hFF;

assign    {ip_hdr_ver_hlen}                                          = IP_VER;
assign    {ether_hdr_type_code[1],ether_hdr_type_code[0]}                              = ETH_TYPE;
assign    ip_hdr_proto                                                  = UDP_PROTO;
assign    ip_hdr_ttl                                                    = IP_TTL;

module udp_check_summ
(                                            
    input                   iclk,
    input     [15:0]        packet_in,
    output [15:0]        check_summ_out,
    input                    data_valid,
    input                    sop
                                                
);

logic [15:0] accum_rg;
logic [16:0] carry_check;
logic          carry_16;

assign    carry_check    = accum_rg + packet_in;
assign  check_summ_out = 16'hFFFF - accum_rg;

///

  always_ff @ (posedge iclk) begin
//        if (sop && data_valid)
//            accum_rg <= packet_in;
//        else if (sop && !data_valid)
        if (sop)
            accum_rg <= '0;
        else begin
            if(data_valid) begin
                    accum_rg <= accum_rg + packet_in + carry_check[16];
            end
        end
    end

endmodule

        if(avs_s0_write && avs_s0_chipselect) begin
            unique case(avs_s0_address)
                `ADDR_ETHER_DEST_MAC_0        :    ether_hdr_da[0] <= avs_s0_writedata[7:0];    
                `ADDR_ETHER_DEST_MAC_1        :    ether_hdr_da[1] <= avs_s0_writedata[7:0];
                `ADDR_ETHER_DEST_MAC_2        :    ether_hdr_da[2] <= avs_s0_writedata[7:0];
                `ADDR_ETHER_DEST_MAC_3        :    ether_hdr_da[3] <= avs_s0_writedata[7:0];
                `ADDR_ETHER_DEST_MAC_4        :    ether_hdr_da[4] <= avs_s0_writedata[7:0];
                `ADDR_ETHER_DEST_MAC_5        :    ether_hdr_da[5] <= avs_s0_writedata[7:0];
                
                `ADDR_ETHER_SOURCE_MAC_0    :    ether_hdr_sa[0] <= avs_s0_writedata[7:0];        
                `ADDR_ETHER_SOURCE_MAC_1    :     ether_hdr_sa[1] <= avs_s0_writedata[7:0];
                `ADDR_ETHER_SOURCE_MAC_2    :    ether_hdr_sa[2] <= avs_s0_writedata[7:0];
                `ADDR_ETHER_SOURCE_MAC_3    :    ether_hdr_sa[3] <= avs_s0_writedata[7:0];
                `ADDR_ETHER_SOURCE_MAC_4    :    ether_hdr_sa[4] <= avs_s0_writedata[7:0];
                `ADDR_ETHER_SOURCE_MAC_5    :    ether_hdr_sa[5] <= avs_s0_writedata[7:0];
                ///
                `ADDR_IP_TOS                    :    {ip_hdr_tos[1], ip_hdr_tos[0]}                             <= avs_s0_writedata[15:0];                     
                //`ADDR_IP_TLEN                    :    {ip_hdr_tlen[1],ip_hdr_tlen[0]}                            <= avs_s0_writedata[15:0];
                `ADDR_IP_ID                        :    {ip_hdr_id[1],ip_hdr_id[0]}                                      <= avs_s0_writedata[15:0];
                `ADDR_IP_FRAG_OFF_            :    {ip_hdr_frag_off[1],ip_hdr_frag_off[0]}                    <= avs_s0_writedata[15:0];
                `ADDR_IP_SOURCE_ADDRESS        :    {ip_hdr_sa[3],ip_hdr_sa[2],ip_hdr_sa[1],ip_hdr_sa[0]} <= avs_s0_writedata;
                `ADDR_IP_DEST_ADDRESS        :    {ip_hdr_da[3],ip_hdr_da[2],ip_hdr_da[1],ip_hdr_da[0]} <= avs_s0_writedata;
                ///
                `ADDR_UDP_SOURCE_PORT        :    {udp_hdr_sp[1],udp_hdr_sp[0]}                                <= avs_s0_writedata[15:0];
                `ADDR_UDP_DEST_PORT            :    {udp_hdr_dp[1],udp_hdr_dp[0]}                                <= avs_s0_writedata[15:0];         
            endcase
        end

always_comb begin
    case (cnt_check_words)
        0: next_check_ipv4_word = {ip_hdr_ver_hlen, ip_hdr_tos};
        1: next_check_ipv4_word = {ip_hdr_tlen[1],ip_hdr_tlen[0]};
        2: next_check_ipv4_word = {ip_hdr_id[1],ip_hdr_id[0]};
        3: next_check_ipv4_word = {ip_hdr_frag_off[1],ip_hdr_frag_off[0]};
        4: next_check_ipv4_word = {ip_hdr_ttl,ip_hdr_proto};
        5: next_check_ipv4_word = {ip_hdr_sa[3],ip_hdr_sa[2]};
        6: next_check_ipv4_word = {ip_hdr_sa[1],ip_hdr_sa[0]};
        7: next_check_ipv4_word = {ip_hdr_da[3],ip_hdr_da[2]};
        8: next_check_ipv4_word = {ip_hdr_da[1],ip_hdr_da[0]};
        default: next_check_ipv4_word = '0;
    endcase
end

case (cnt_check_words)
         //udp pseudo header
        0: next_check_udp_word = {ip_hdr_sa[3],ip_hdr_sa[2]};
        1: next_check_udp_word = {ip_hdr_sa[1],ip_hdr_sa[0]};
        2: next_check_udp_word = {ip_hdr_da[3],ip_hdr_da[2]};
        3: next_check_udp_word = {ip_hdr_da[1],ip_hdr_da[0]};
        4: next_check_udp_word = {16'h00,ip_hdr_proto};
        5: next_check_udp_word = {udp_hdr_len[1],udp_hdr_len[0]};
        //udp header
        6: next_check_udp_word = {udp_hdr_sp[1],udp_hdr_sp[0]};
        7: next_check_udp_word = {udp_hdr_dp[1],udp_hdr_dp[0]};
        8: next_check_udp_word = {udp_hdr_len[1],udp_hdr_len[0]};
        
        default: next_check_udp_word = данные;