Subversion Repositories 1g_ethernet_dpi

//////////////////////////////////////////////////////////////////////////////////

// Company:

// Engineer:        IK

//

// Create Date:     11:35:01 03/21/2013

// Design Name:

// Module Name:     eth_host_bfm

// Project Name:

// Target Devices:

// Tool versions:

// Description:

//

//                  DPC-C import:

//                      -> 'test_bfm' / {net-adapt}

//

//                  DPI-C export:

//

//                      -> host_initial

//                      -> host_delay

//                      -> host_final

//

//                      -> eth_frm_read_len

//                      -> eth_frm_read

//

//                      -> eth_frm_write_len

//                      -> eth_frm_write

//

// Revision:

// Revision 0.01 - File Created,

//

//////////////////////////////////////////////////////////////////////////////////

`timescale 1ns / 1ps

module eth_host_bfm #(parameter p_ETH_MTU = 1536)

(

    // RSTi

    input   i_arst,

    // RGMII-RX

    input           i_rgmii_rx_clk,

    input           i_rgmii_rx_ctrl,

    input   [ 3:0]  iv_rgmii_rxd,

    // RGMII-TX

    output  logic           o_rgmii_tx_clk,

    output  logic           o_rgmii_tx_ctrl,

    output  logic   [ 3:0]  ov_rgmii_txd

);

//////////////////////////////////////////////////////////////////////////////////

localparam lp_BQNTY = 8;

//////////////////////////////////////////////////////////////////////////////////

// eth-pkt record

typedef struct {

    bit [7:0] data[];

    int len;

} packet_t;

// mbox for eth-pkt

typedef mailbox#(packet_t) pkt_mbox_t;

//////////////////////////////////////////////////////////////////////////////////

    // PKT-mboxes / TX+RX parts

    pkt_mbox_t tx_pkt_mailbox = new(/*lp_BQNTY*/);

    pkt_mbox_t rx_pkt_mailbox = new(lp_BQNTY);

    // 4dbg-tx

    packet_t    tx_pkt;

    int         tx_pkt_idx;

    // 4dbg-rx

    packet_t    rx_pkt;

    int         rx_pkt_idx;

    bit [7:0] data0 [256];

    int len0;

    // low-tx

    packet_t        tx_pkt_low;

    bit     [ 7:0]  sv_rgmii_txd;

    int             si_eth_tx_frm_cnt;

    // low-rx

    packet_t        rx_pkt_low;

    bit     [ 7:0]  sv_rgmii_rxd;

    bit             s_rgmii_rx_frm_end;

    int             si_eth_rx_frm_cnt;

//////////////////////////////////////////////////////////////////////////////////

//

// RGMII RX-TX Init

//

initial

begin   :   INIT

    // tx-ctrl

    o_rgmii_tx_clk = 0;

    o_rgmii_tx_ctrl = 0;

    ov_rgmii_txd = 0;

    // pkt

    tx_pkt_low.data = new [p_ETH_MTU];

    tx_pkt_low.len = -1;

    rx_pkt_low.data = new [p_ETH_MTU];

    rx_pkt_low.len = -1;

    rx_pkt.data = new [p_ETH_MTU];

    rx_pkt.len = -1;

    rx_pkt_idx = 0;

    tx_pkt_idx = 0;

    tx_pkt.data = new [p_ETH_MTU];

    tx_pkt.len = -1;

            // init-data

            tx_pkt.data[0] = 8'h55;

            tx_pkt.data[1] = 8'h55;

            tx_pkt.data[2] = 8'h55;

            tx_pkt.data[3] = 8'h55;

            tx_pkt.data[4] = 8'h55;

            tx_pkt.data[5] = 8'h55;

            tx_pkt.data[6] = 8'h55;

            tx_pkt.data[7] = 8'hD5;

    // Final

end

//////////////////////////////////////////////////////////////////////////////////

//

// RGMII RX-TX Clocking

//

clocking cb_rx @(posedge i_rgmii_rx_clk);

endclocking : cb_rx;

clocking cb_tx @(posedge o_rgmii_tx_clk);

endclocking : cb_tx;

always

begin   :   TX_CLK

    #(4ns) o_rgmii_tx_clk <= !o_rgmii_tx_clk;

end

//////////////////////////////////////////////////////////////////////////////////

//

// HDL RGMII

//

task run_tx;

    //

   forever

        eth_tx_frm();

    // Final

endtask : run_tx

task run_rx;

    //

   forever

        eth_rx_frm();

    // Final

endtask : run_rx

//////////////////////////////////////////////////////////////////////////////////

//

// RGMII-TX

//

task eth_tx_frm;

    //

    //

    @cb_tx;

    if (tx_pkt_mailbox.num())

        begin   :   ETH_TX

            // init

            sv_rgmii_txd = 0;

            si_eth_tx_frm_cnt = 0;

            // get

            tx_pkt_mailbox.get(tx_pkt_low);

            // chk

            /*if ((tx_pkt_low.len + 8) < (64 + 8))

                tx_pkt_low.len = 64;*/

            // out

            do begin : OUT

                sv_rgmii_txd = tx_pkt_low.data[si_eth_tx_frm_cnt++];

                write_byte(sv_rgmii_txd, (si_eth_tx_frm_cnt == (tx_pkt_low.len + 8)));

            end while (si_eth_tx_frm_cnt != (tx_pkt_low.len + 8));

        end

    // Final

endtask : eth_tx_frm

task write_byte(input bit [7:0] iv_data, input bit i_final);

    //

    @(negedge o_rgmii_tx_clk); #2ns;

    o_rgmii_tx_ctrl <= 1;

    ov_rgmii_txd <= iv_data[3:0];

    @(posedge o_rgmii_tx_clk); #2ns;

    ov_rgmii_txd <= iv_data[7:4];

    if (i_final)

        begin   :   END

            @(negedge o_rgmii_tx_clk); #2ns;

            o_rgmii_tx_ctrl <= 0;

            ov_rgmii_txd <= 0;

        end

    // Final

endtask : write_byte

//////////////////////////////////////////////////////////////////////////////////

//

// RGMII-RX

//

task eth_rx_frm;

    //

    // wait for RXC rise

    do @(posedge i_rgmii_rx_clk or negedge i_rgmii_rx_clk);

    while(i_rgmii_rx_ctrl == 0);

    // init

    sv_rgmii_rxd = 0;

    s_rgmii_rx_frm_end = 0;

    si_eth_rx_frm_cnt = 0;

    // rx-proc

    do begin : RX

        read_byte((si_eth_rx_frm_cnt == 0), sv_rgmii_rxd, s_rgmii_rx_frm_end);

        if (!s_rgmii_rx_frm_end)

            begin   :   WRK

                if (si_eth_rx_frm_cnt > 7) // !=> cut {55, .., D5} here

                    begin   :   WR_RX_PKT

                        rx_pkt_low.data[(si_eth_rx_frm_cnt - 8)] = sv_rgmii_rxd;

                    end

                si_eth_rx_frm_cnt++;

            end

    end while (s_rgmii_rx_frm_end == 0);

    s_rgmii_rx_frm_end = 0;

    rx_pkt_low.len = (si_eth_rx_frm_cnt - 8); $display("[%t]: %m: len=%x", $time, rx_pkt_low.len);

    rx_pkt_mailbox.put(rx_pkt_low);

    // final-dly

    @cb_rx;

    // Final

endtask : eth_rx_frm

task read_byte(input bit i_init, output bit [7:0] ov_data, output bit o_end);

    // init

    ov_data = -1;

    o_end = 0;

    // rx-dly

    if (i_init == 0) // 2nd, 3rd, .. starts

        @(posedge i_rgmii_rx_clk or negedge i_rgmii_rx_clk); // initial start - NO-DLY (eth_rx_frm -> 'wait for RXC rise')

    // lsb / prev detected RXC == 1 {RXEN-marker}

    ov_data[3:0] = iv_rgmii_rxd;

    // msb

    @(posedge i_rgmii_rx_clk or negedge i_rgmii_rx_clk);

    ov_data[7:4] = iv_rgmii_rxd;

    // frm-end chk

    if (i_rgmii_rx_ctrl == 0)

        o_end = 1;

    // Final

endtask : read_byte

//////////////////////////////////////////////////////////////////////////////////

//

// DPC-C routines

//  => GLBL

//

// DPI-C export / cpp-hdl

export "DPI-C" task host_initial;

export "DPI-C" task host_delay;

export "DPI-C" task host_final;

task host_initial;

    //

    do @cb_tx; // use our stable TX-CLK

    while (i_arst == 1);

    repeat(100) @cb_tx;

    $display("[%t]: %m: START", $time);

    // Final

endtask : host_initial

task host_delay(input int ii_value);

    //

    repeat(ii_value)

        @cb_tx;

    // Final

endtask : host_delay

task host_final;

    //

    repeat(10) @cb_tx;

    $finish;//$stop;

    // Final

endtask : host_final

// DPC-C import / MAIN

import "DPI-C" context task test_bfm();

initial

begin   :   MAIN_NET_ADAPT

    test_bfm();

end

//////////////////////////////////////////////////////////////////////////////////

//

// DPC-C routines

//  => RGMII-RX

//

export "DPI-C" task eth_frm_read_len;

export "DPI-C" task eth_frm_read;

task eth_frm_read_len(output int ov_len);

    //

    @cb_rx; // !!!

    if (rx_pkt_mailbox.num())

        begin   :   HAVE_RXD

            rx_pkt_mailbox.get(rx_pkt);

            ov_len = rx_pkt.len;

            rx_pkt_idx++; $display("[%t]: %m: len=%x", $time, rx_pkt.len);

        end

    else

        ov_len = -1;

    // Final

endtask : eth_frm_read_len

task eth_frm_read(output int ov_data, input int iv_position);

    //

    ov_data = rx_pkt.data[iv_position];

    // Final

endtask : eth_frm_read

//////////////////////////////////////////////////////////////////////////////////

//

// DPC-C routines

//  => RGMII-TX

//

export "DPI-C" task eth_frm_write_len; // !=> init pkt-PUT

export "DPI-C" task eth_frm_write;

task eth_frm_write_len(input int iv_len);

    len0 = iv_len;

    for (int i = 0; i < iv_len; i++) begin data0[i] = tx_pkt.data[i]; end

    // put

    tx_pkt.len = iv_len;

    tx_pkt_mailbox.put(tx_pkt);

    // nxt-idx

    tx_pkt_idx++;

    // Final

endtask : eth_frm_write_len;

task eth_frm_write(input int iv_data, input int iv_position);

    // wr

    @cb_tx; // !!!

    tx_pkt.data[iv_position+8] = iv_data;

    // Final

endtask : eth_frm_write

//////////////////////////////////////////////////////////////////////////////////

endmodule